From 71f9bda3cda291eba9aece9ead1708d3c9de349b Mon Sep 17 00:00:00 2001
From: Hendrik Liebau <mail@hendrik-liebau.de>
Date: Wed, 21 Jan 2026 16:11:58 +0100
Subject: [PATCH 1/8] [ci] Fix Rspack/Turbopack test manifest generation
 (#88845)

The recent change to always run all tests without aborting on failure
(#88435) inadvertently broke manifest generation. Previously, test
output was emitted for all tests when `NEXT_TEST_CONTINUE_ON_ERROR` was
set, but that variable was removed. Now test output is only emitted for
failing tests, causing the manifest to lose all passing test entries.

This adds a new `NEXT_TEST_EMIT_ALL_OUTPUT` environment variable that
restores the full output behavior specifically for the manifest
generation workflows.
---
 .github/workflows/integration_tests_reusable.yml | 2 ++
 run-tests.js                                     | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/integration_tests_reusable.yml b/.github/workflows/integration_tests_reusable.yml
index a83f13f472f16c..a7738651ffe7c2 100644
--- a/.github/workflows/integration_tests_reusable.yml
+++ b/.github/workflows/integration_tests_reusable.yml
@@ -94,6 +94,7 @@ jobs:
         export NEXT_TEST_MODE=${{
           inputs.test_type == 'development' && 'dev' || 'start'
         }}
+        export NEXT_TEST_EMIT_ALL_OUTPUT=1
 
         ${{ inputs.run_before_test }}
 
@@ -129,6 +130,7 @@ jobs:
             'TURBOPACK_DEV=1' ||
             'TURBOPACK_BUILD=1'
         }}
+        export NEXT_TEST_EMIT_ALL_OUTPUT=1
 
         ${{ inputs.run_before_test }}
 
diff --git a/run-tests.js b/run-tests.js
index 8dccfe3b1b8465..377e8f3e3e723b 100644
--- a/run-tests.js
+++ b/run-tests.js
@@ -695,8 +695,9 @@ ${ENDGROUP}`)
       console.error(`${test.file} failed to pass within ${numRetries} retries`)
     }
 
-    // Emit test output, parsed by the commenter webhook to notify about failing tests
-    if (!passed && isTestJob) {
+    // Emit test output, parsed by the commenter webhook to notify about failing tests.
+    // Also emit for all tests when NEXT_TEST_EMIT_ALL_OUTPUT is set (for manifest generation).
+    if ((!passed || process.env.NEXT_TEST_EMIT_ALL_OUTPUT) && isTestJob) {
       try {
         const testsOutput = await fsp.readFile(
           `${test.file}${RESULTS_EXT}`,

From bed512a381250493a2e2e0f9185c69960c713fd9 Mon Sep 17 00:00:00 2001
From: Tobias Koppers <tobias.koppers@googlemail.com>
Date: Wed, 21 Jan 2026 16:33:01 +0100
Subject: [PATCH 2/8] Turbopack: show compressed size for print_cache_item_size
 (#88850)

### What?

Improve the feature flag to show compressed size
---
 Cargo.lock                                    |  1 +
 .../crates/turbo-tasks-backend/Cargo.toml     |  3 +-
 .../turbo-tasks-backend/src/backend/mod.rs    | 48 ++++++++++++++-----
 3 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cdb13edd140b87..c0bda7edbfeb1a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9431,6 +9431,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "indexmap 2.9.0",
  "lmdb-rkv",
+ "lzzzz",
  "once_cell",
  "parking_lot",
  "rand 0.9.0",
diff --git a/turbopack/crates/turbo-tasks-backend/Cargo.toml b/turbopack/crates/turbo-tasks-backend/Cargo.toml
index 4e198ef2df291f..8dcd7a4b6c8edd 100644
--- a/turbopack/crates/turbo-tasks-backend/Cargo.toml
+++ b/turbopack/crates/turbo-tasks-backend/Cargo.toml
@@ -14,7 +14,7 @@ workspace = true
 
 [features]
 default = []
-print_cache_item_size = []
+print_cache_item_size = ["dep:lzzzz"]
 no_fast_stale = []
 verify_serialization = []
 verify_aggregation_graph = []
@@ -42,6 +42,7 @@ either = { workspace = true }
 hashbrown = { workspace = true, features = ["raw"] }
 indexmap = { workspace = true }
 lmdb-rkv = { version = "0.14.0", optional = true }
+lzzzz = { version = "1.1.0", optional = true }
 once_cell = { workspace = true }
 parking_lot = { workspace = true }
 rand = { workspace = true }
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
index ed44f3ef298a7e..d018ec6e0103ba 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
@@ -1146,19 +1146,31 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         #[derive(Default)]
         struct TaskCacheStats {
             data: usize,
+            data_compressed: usize,
             data_count: usize,
             meta: usize,
+            meta_compressed: usize,
             meta_count: usize,
         }
         #[cfg(feature = "print_cache_item_size")]
         impl TaskCacheStats {
-            fn add_data(&mut self, len: usize) {
-                self.data += len;
+            fn compressed_size(data: &[u8]) -> Result<usize> {
+                Ok(lzzzz::lz4::Compressor::new()?.next_to_vec(
+                    data,
+                    &mut Vec::new(),
+                    lzzzz::lz4::ACC_LEVEL_DEFAULT,
+                )?)
+            }
+
+            fn add_data(&mut self, data: &[u8]) {
+                self.data += data.len();
+                self.data_compressed += Self::compressed_size(data).unwrap_or(0);
                 self.data_count += 1;
             }
 
-            fn add_meta(&mut self, len: usize) {
-                self.meta += len;
+            fn add_meta(&mut self, data: &[u8]) {
+                self.meta += data.len();
+                self.meta_compressed += Self::compressed_size(data).unwrap_or(0);
                 self.meta_count += 1;
             }
         }
@@ -1183,7 +1195,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                                         .lock()
                                         .entry(self.get_task_description(task_id))
                                         .or_default()
-                                        .add_meta(meta.len());
+                                        .add_meta(&meta);
                                     Some(meta)
                                 }
                                 None => None,
@@ -1203,7 +1215,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                                         .lock()
                                         .entry(self.get_task_description(task_id))
                                         .or_default()
-                                        .add_data(data.len());
+                                        .add_data(&data);
                                     Some(data)
                                 }
                                 None => None,
@@ -1250,23 +1262,37 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                     .collect::<Vec<_>>();
                 if !task_cache_stats.is_empty() {
                     task_cache_stats.sort_unstable_by(|(key_a, stats_a), (key_b, stats_b)| {
-                        (stats_b.data + stats_b.meta, key_b)
-                            .cmp(&(stats_a.data + stats_a.meta, key_a))
+                        (stats_b.data_compressed + stats_b.meta_compressed, key_b)
+                            .cmp(&(stats_a.data_compressed + stats_a.meta_compressed, key_a))
                     });
                     println!("Task cache stats:");
                     for (task_desc, stats) in task_cache_stats {
-                        use std::ops::Div;
-
                         use turbo_tasks::util::FormatBytes;
 
                         println!(
-                            "  {} {task_desc} = {} meta ({} x {}), {} data ({} x {})",
+                            "  {} ({}) {task_desc} = {} ({}) meta {} x {} ({}), {} ({}) data {} x \
+                             {} ({})",
+                            FormatBytes(stats.data_compressed + stats.meta_compressed),
                             FormatBytes(stats.data + stats.meta),
+                            FormatBytes(stats.meta_compressed),
                             FormatBytes(stats.meta),
                             stats.meta_count,
+                            FormatBytes(
+                                stats
+                                    .meta_compressed
+                                    .checked_div(stats.meta_count)
+                                    .unwrap_or(0)
+                            ),
                             FormatBytes(stats.meta.checked_div(stats.meta_count).unwrap_or(0)),
+                            FormatBytes(stats.data_compressed),
                             FormatBytes(stats.data),
                             stats.data_count,
+                            FormatBytes(
+                                stats
+                                    .data_compressed
+                                    .checked_div(stats.data_count)
+                                    .unwrap_or(0)
+                            ),
                             FormatBytes(stats.data.checked_div(stats.data_count).unwrap_or(0)),
                         );
                     }

From a3500c3227de0bda8e34c2a347047e88a524d9da Mon Sep 17 00:00:00 2001
From: Hendrik Liebau <mail@hendrik-liebau.de>
Date: Wed, 21 Jan 2026 17:18:44 +0100
Subject: [PATCH 3/8] [test] Fix deploy test of
 `cache-components.server-action.test.ts` (#88854)

When deployed, the sentinels where showing `at runtime` instead of `at
buildtime`. There are two reasons for this:

1. The page sentinel was accidentally rendered in a client component,
which causes a hydration mismatch, and the value toggling from `at
buildtime` to `at runtime` when the page is hydrated before the
assertion is done.
2. The middleware was setting sentinel cookies that are intended for the
`/cookies/*` pages, but not for the `/server-action-inline` page. This
caused the server action (which is triggered in the second test) to
consider the page as revalidated, which then led the client router to
refetch the page. With `next start` this is not a problem because the
RSC response is prerendered at build time, and returned as a static
file, which contains the correct sentinel values. However, when deployed
on Vercel, the RSC request results in an ISR cache miss for some reason,
which causes the page to be revalidated (with runtime sentinel values),
and then the third test fails when it receives the regenerated response
instead of the build-time prerender result. This needs to be
investigated separately, but for now we disable the middleware from
setting cookies on this page to prevent the ISR revalidation request.

closes #88817
closes NAR-740

> [!TIP]
> Best reviewed with hidden whitespace changes.
---
 .../app/server-action-inline/form.tsx         |  2 -
 .../app/server-action-inline/page.tsx         | 24 +++---
 .../app-dir/cache-components/middleware.ts    | 77 +++++++++++--------
 3 files changed, 59 insertions(+), 44 deletions(-)

diff --git a/test/e2e/app-dir/cache-components/app/server-action-inline/form.tsx b/test/e2e/app-dir/cache-components/app/server-action-inline/form.tsx
index 67b7e7d0931eb1..bc284912d29c77 100644
--- a/test/e2e/app-dir/cache-components/app/server-action-inline/form.tsx
+++ b/test/e2e/app-dir/cache-components/app/server-action-inline/form.tsx
@@ -1,7 +1,6 @@
 'use client'
 
 import { ReactNode, useActionState } from 'react'
-import { getSentinelValue } from '../getSentinelValue'
 
 export function Form({ action }: { action: () => Promise<ReactNode> }) {
   const [result, formAction] = useActionState(action, 'initial')
@@ -11,7 +10,6 @@ export function Form({ action }: { action: () => Promise<ReactNode> }) {
       <h1>Inline Server Action with Cache Components</h1>
       <button>Submit</button>
       <p>{result}</p>
-      <div id="page">{getSentinelValue()}</div>
     </form>
   )
 }
diff --git a/test/e2e/app-dir/cache-components/app/server-action-inline/page.tsx b/test/e2e/app-dir/cache-components/app/server-action-inline/page.tsx
index 268bc5afef9621..f83bf1b4fd7b10 100644
--- a/test/e2e/app-dir/cache-components/app/server-action-inline/page.tsx
+++ b/test/e2e/app-dir/cache-components/app/server-action-inline/page.tsx
@@ -1,4 +1,5 @@
 import { Form } from './form'
+import { getSentinelValue } from '../getSentinelValue'
 
 export default function Page() {
   const simpleValue = 'result'
@@ -7,16 +8,19 @@ export default function Page() {
   // Async components emit timing chunks
   const timedValue = <HasTimingInfo />
   return (
-    <Form
-      action={async () => {
-        'use server'
-        return (
-          <>
-            {simpleValue} {jsxValue} {timedValue}
-          </>
-        )
-      }}
-    />
+    <>
+      <Form
+        action={async () => {
+          'use server'
+          return (
+            <>
+              {simpleValue} {jsxValue} {timedValue}
+            </>
+          )
+        }}
+      />
+      <div id="page">{getSentinelValue()}</div>
+    </>
   )
 }
 
diff --git a/test/e2e/app-dir/cache-components/middleware.ts b/test/e2e/app-dir/cache-components/middleware.ts
index ff76b1470b8749..61872f0040f838 100644
--- a/test/e2e/app-dir/cache-components/middleware.ts
+++ b/test/e2e/app-dir/cache-components/middleware.ts
@@ -2,43 +2,56 @@ import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 
 export function middleware(request: NextRequest) {
-  // Clone the request headers and set a new header `x-hello-from-middleware1`
-  const requestHeaders = new Headers(request.headers)
-  requestHeaders.set('x-sentinel', 'hello')
-  requestHeaders.set('x-sentinel-path', request.nextUrl.pathname)
-  requestHeaders.set(
-    'x-sentinel-rand',
-    ((Math.random() * 100000) | 0).toString(16)
-  )
+  if (
+    request.nextUrl.pathname.startsWith('/headers/') ||
+    request.nextUrl.pathname.endsWith('dynamic_api_headers')
+  ) {
+    // Clone the request headers and set a new header `x-hello-from-middleware1`
+    const requestHeaders = new Headers(request.headers)
+    requestHeaders.set('x-sentinel', 'hello')
+    requestHeaders.set('x-sentinel-path', request.nextUrl.pathname)
+    requestHeaders.set(
+      'x-sentinel-rand',
+      ((Math.random() * 100000) | 0).toString(16)
+    )
 
-  const response = NextResponse.next({
-    request: {
-      // New request headers
-      headers: requestHeaders,
-    },
-  })
-  response.cookies.set('x-sentinel', 'hello', {
-    httpOnly: true,
-    sameSite: 'strict',
-    maxAge: 60 * 60 * 24 * 7, // 1 week
-    path: '/',
-  })
-  response.cookies.set('x-sentinel-path', request.nextUrl.pathname, {
-    httpOnly: true,
-    sameSite: 'strict',
-    maxAge: 60 * 60 * 24 * 7, // 1 week
-    path: '/',
-  })
-  response.cookies.set(
-    'x-sentinel-rand',
-    ((Math.random() * 100000) | 0).toString(16),
-    {
+    return NextResponse.next({
+      request: {
+        // New request headers
+        headers: requestHeaders,
+      },
+    })
+  }
+
+  const response = NextResponse.next()
+
+  if (
+    request.nextUrl.pathname.startsWith('/cookies/') ||
+    request.nextUrl.pathname.endsWith('dynamic_api_cookies')
+  ) {
+    response.cookies.set('x-sentinel', 'hello', {
+      httpOnly: true,
+      sameSite: 'strict',
+      maxAge: 60 * 60 * 24 * 7, // 1 week
+      path: '/',
+    })
+    response.cookies.set('x-sentinel-path', request.nextUrl.pathname, {
       httpOnly: true,
       sameSite: 'strict',
       maxAge: 60 * 60 * 24 * 7, // 1 week
       path: '/',
-    }
-  )
+    })
+    response.cookies.set(
+      'x-sentinel-rand',
+      ((Math.random() * 100000) | 0).toString(16),
+      {
+        httpOnly: true,
+        sameSite: 'strict',
+        maxAge: 60 * 60 * 24 * 7, // 1 week
+        path: '/',
+      }
+    )
+  }
 
   return response
 }

From 3fe7d63f857302d15e753a7a02753eff3fb1f91c Mon Sep 17 00:00:00 2001
From: nextjs-bot <it+nextjs-bot@vercel.com>
Date: Wed, 21 Jan 2026 16:24:55 +0000
Subject: [PATCH 4/8] v16.2.0-canary.0

---
 lerna.json                                   |  2 +-
 packages/create-next-app/package.json        |  2 +-
 packages/eslint-config-next/package.json     |  4 ++--
 packages/eslint-plugin-internal/package.json |  2 +-
 packages/eslint-plugin-next/package.json     |  2 +-
 packages/font/package.json                   |  2 +-
 packages/next-bundle-analyzer/package.json   |  2 +-
 packages/next-codemod/package.json           |  2 +-
 packages/next-env/package.json               |  2 +-
 packages/next-mdx/package.json               |  2 +-
 packages/next-plugin-storybook/package.json  |  2 +-
 packages/next-polyfill-module/package.json   |  2 +-
 packages/next-polyfill-nomodule/package.json |  2 +-
 packages/next-routing/package.json           |  2 +-
 packages/next-rspack/package.json            |  2 +-
 packages/next-swc/package.json               |  2 +-
 packages/next/package.json                   | 14 +++++++-------
 packages/react-refresh-utils/package.json    |  2 +-
 packages/third-parties/package.json          |  4 ++--
 pnpm-lock.yaml                               | 16 ++++++++--------
 20 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/lerna.json b/lerna.json
index 3c997c5cb3a2a1..adfaabf5c5aa7a 100644
--- a/lerna.json
+++ b/lerna.json
@@ -15,5 +15,5 @@
       "registry": "https://registry.npmjs.org/"
     }
   },
-  "version": "16.1.1-canary.36"
+  "version": "16.2.0-canary.0"
 }
\ No newline at end of file
diff --git a/packages/create-next-app/package.json b/packages/create-next-app/package.json
index 5d33bce62d7d19..0f066f884d61f7 100644
--- a/packages/create-next-app/package.json
+++ b/packages/create-next-app/package.json
@@ -1,6 +1,6 @@
 {
   "name": "create-next-app",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "keywords": [
     "react",
     "next",
diff --git a/packages/eslint-config-next/package.json b/packages/eslint-config-next/package.json
index 90ff28bb35dc79..8e19ce1410f00c 100644
--- a/packages/eslint-config-next/package.json
+++ b/packages/eslint-config-next/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-next",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "ESLint configuration used by Next.js.",
   "license": "MIT",
   "repository": {
@@ -12,7 +12,7 @@
     "dist"
   ],
   "dependencies": {
-    "@next/eslint-plugin-next": "16.1.1-canary.36",
+    "@next/eslint-plugin-next": "16.2.0-canary.0",
     "eslint-import-resolver-node": "^0.3.6",
     "eslint-import-resolver-typescript": "^3.5.2",
     "eslint-plugin-import": "^2.32.0",
diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json
index 09727ae2bbd00f..f3338a11c6fee9 100644
--- a/packages/eslint-plugin-internal/package.json
+++ b/packages/eslint-plugin-internal/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@next/eslint-plugin-internal",
   "private": true,
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "ESLint plugin for working on Next.js.",
   "exports": {
     ".": "./src/eslint-plugin-internal.js"
diff --git a/packages/eslint-plugin-next/package.json b/packages/eslint-plugin-next/package.json
index 353acb45d98fa6..71d390ade77004 100644
--- a/packages/eslint-plugin-next/package.json
+++ b/packages/eslint-plugin-next/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/eslint-plugin-next",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "ESLint plugin for Next.js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
diff --git a/packages/font/package.json b/packages/font/package.json
index 6b59d3927352eb..e5b85400f50d2d 100644
--- a/packages/font/package.json
+++ b/packages/font/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@next/font",
   "private": true,
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/font"
diff --git a/packages/next-bundle-analyzer/package.json b/packages/next-bundle-analyzer/package.json
index 2c451bf2e46366..b5b8e4fc69473c 100644
--- a/packages/next-bundle-analyzer/package.json
+++ b/packages/next-bundle-analyzer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/bundle-analyzer",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "main": "index.js",
   "types": "index.d.ts",
   "license": "MIT",
diff --git a/packages/next-codemod/package.json b/packages/next-codemod/package.json
index 48598696c1d669..591c54d6165946 100644
--- a/packages/next-codemod/package.json
+++ b/packages/next-codemod/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "license": "MIT",
   "repository": {
     "type": "git",
diff --git a/packages/next-env/package.json b/packages/next-env/package.json
index cf1da86c73ab43..6c6b8587aa3ed4 100644
--- a/packages/next-env/package.json
+++ b/packages/next-env/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/env",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "keywords": [
     "react",
     "next",
diff --git a/packages/next-mdx/package.json b/packages/next-mdx/package.json
index fb897f0ce2e955..9420496a96e4b9 100644
--- a/packages/next-mdx/package.json
+++ b/packages/next-mdx/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/mdx",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "main": "index.js",
   "license": "MIT",
   "repository": {
diff --git a/packages/next-plugin-storybook/package.json b/packages/next-plugin-storybook/package.json
index 1956d02445975f..1e3bfa431f2300 100644
--- a/packages/next-plugin-storybook/package.json
+++ b/packages/next-plugin-storybook/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/plugin-storybook",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/next-plugin-storybook"
diff --git a/packages/next-polyfill-module/package.json b/packages/next-polyfill-module/package.json
index 3649fc25bc2d7f..5615447bc28ef4 100644
--- a/packages/next-polyfill-module/package.json
+++ b/packages/next-polyfill-module/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/polyfill-module",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "A standard library polyfill for ES Modules supporting browsers (Edge 16+, Firefox 60+, Chrome 61+, Safari 10.1+)",
   "main": "dist/polyfill-module.js",
   "license": "MIT",
diff --git a/packages/next-polyfill-nomodule/package.json b/packages/next-polyfill-nomodule/package.json
index 1fa2bbbb569464..b1f24f56b0c214 100644
--- a/packages/next-polyfill-nomodule/package.json
+++ b/packages/next-polyfill-nomodule/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/polyfill-nomodule",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "A polyfill for non-dead, nomodule browsers.",
   "main": "dist/polyfill-nomodule.js",
   "license": "MIT",
diff --git a/packages/next-routing/package.json b/packages/next-routing/package.json
index 58c368d05076b6..41be69a7d81061 100644
--- a/packages/next-routing/package.json
+++ b/packages/next-routing/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/routing",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "keywords": [
     "react",
     "next",
diff --git a/packages/next-rspack/package.json b/packages/next-rspack/package.json
index c00e1673550894..6ae330bb999e48 100644
--- a/packages/next-rspack/package.json
+++ b/packages/next-rspack/package.json
@@ -1,6 +1,6 @@
 {
   "name": "next-rspack",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/next-rspack"
diff --git a/packages/next-swc/package.json b/packages/next-swc/package.json
index 8de6aa74371883..ada17bc13c5be2 100644
--- a/packages/next-swc/package.json
+++ b/packages/next-swc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/swc",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "private": true,
   "files": [
     "native/"
diff --git a/packages/next/package.json b/packages/next/package.json
index 23d10225d5b876..bfd5572d8bd2e1 100644
--- a/packages/next/package.json
+++ b/packages/next/package.json
@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -97,7 +97,7 @@
     ]
   },
   "dependencies": {
-    "@next/env": "16.1.1-canary.36",
+    "@next/env": "16.2.0-canary.0",
     "@swc/helpers": "0.5.15",
     "baseline-browser-mapping": "^2.8.3",
     "caniuse-lite": "^1.0.30001579",
@@ -162,11 +162,11 @@
     "@modelcontextprotocol/sdk": "1.18.1",
     "@mswjs/interceptors": "0.23.0",
     "@napi-rs/triples": "1.2.0",
-    "@next/font": "16.1.1-canary.36",
-    "@next/polyfill-module": "16.1.1-canary.36",
-    "@next/polyfill-nomodule": "16.1.1-canary.36",
-    "@next/react-refresh-utils": "16.1.1-canary.36",
-    "@next/swc": "16.1.1-canary.36",
+    "@next/font": "16.2.0-canary.0",
+    "@next/polyfill-module": "16.2.0-canary.0",
+    "@next/polyfill-nomodule": "16.2.0-canary.0",
+    "@next/react-refresh-utils": "16.2.0-canary.0",
+    "@next/swc": "16.2.0-canary.0",
     "@opentelemetry/api": "1.6.0",
     "@playwright/test": "1.51.1",
     "@rspack/core": "1.6.7",
diff --git a/packages/react-refresh-utils/package.json b/packages/react-refresh-utils/package.json
index 443e43028125f9..822f6220375f51 100644
--- a/packages/react-refresh-utils/package.json
+++ b/packages/react-refresh-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/react-refresh-utils",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "description": "An experimental package providing utilities for React Refresh.",
   "repository": {
     "url": "vercel/next.js",
diff --git a/packages/third-parties/package.json b/packages/third-parties/package.json
index 8b5917d51018c4..3f94a6e30a450c 100644
--- a/packages/third-parties/package.json
+++ b/packages/third-parties/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/third-parties",
-  "version": "16.1.1-canary.36",
+  "version": "16.2.0-canary.0",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/third-parties"
@@ -26,7 +26,7 @@
     "third-party-capital": "1.0.20"
   },
   "devDependencies": {
-    "next": "16.1.1-canary.36",
+    "next": "16.2.0-canary.0",
     "outdent": "0.8.0",
     "prettier": "2.5.1",
     "typescript": "5.9.2"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e057d1e2e90690..114679b161d781 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1008,7 +1008,7 @@ importers:
   packages/eslint-config-next:
     dependencies:
       '@next/eslint-plugin-next':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../eslint-plugin-next
       eslint:
         specifier: '>=9.0.0'
@@ -1085,7 +1085,7 @@ importers:
   packages/next:
     dependencies:
       '@next/env':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../next-env
       '@swc/helpers':
         specifier: 0.5.15
@@ -1213,19 +1213,19 @@ importers:
         specifier: 1.2.0
         version: 1.2.0
       '@next/font':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../font
       '@next/polyfill-module':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../next-polyfill-module
       '@next/polyfill-nomodule':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../next-polyfill-nomodule
       '@next/react-refresh-utils':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../react-refresh-utils
       '@next/swc':
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../next-swc
       '@opentelemetry/api':
         specifier: 1.6.0
@@ -1943,7 +1943,7 @@ importers:
         version: 1.0.20
     devDependencies:
       next:
-        specifier: 16.1.1-canary.36
+        specifier: 16.2.0-canary.0
         version: link:../next
       outdent:
         specifier: 0.8.0

From c986bcccf166a89861bbaecd69823baf3e8a2b40 Mon Sep 17 00:00:00 2001
From: Zack Tanner <1939140+ztanner@users.noreply.github.com>
Date: Wed, 21 Jan 2026 08:45:07 -0800
Subject: [PATCH 5/8] fix: preserve cache behavior for PPR fallback shells with
 root params (#88556)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When generating PPR fallback shells, a cache miss during warmup was
being treated as a dynamic hole, so the warmup render never filled new
cache entries. This caused root‑param fallback shells (e.g.
`/en/blog/[slug]`) to suspend even though root params were already
known.

This change always creates a fresh prerender RDC for warmup and copies
any seed hits into it. The final render then uses the warmed cache, so
fallback shells can reuse populated entries without short‑circuiting. On
the export side, we now choose a seed RDC by matching known params (e.g.
locale) so /en/... fallback shells don’t get seeded with /fr/... data.
(Previously, the RDC seed was "last-write-wins".

Fixes NAR-716
---
 packages/next/errors.json                     |   3 +-
 packages/next/src/export/index.ts             | 135 +++++++++++++++---
 packages/next/src/export/worker.ts            |   4 +-
 .../next/src/server/app-render/app-render.tsx |  40 +++---
 .../src/server/use-cache/use-cache-wrapper.ts |   5 +-
 .../app/[locale]/blog/[slug]/page.tsx         |  78 ++++++++++
 .../app/[locale]/layout.tsx                   |  76 ++++++++++
 .../app/[locale]/page.tsx                     |  10 ++
 .../ppr-root-param-fallback/next.config.js    |   8 ++
 .../ppr-root-param-fallback.test.ts           |  30 ++++
 10 files changed, 348 insertions(+), 41 deletions(-)
 create mode 100644 test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/blog/[slug]/page.tsx
 create mode 100644 test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/layout.tsx
 create mode 100644 test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/page.tsx
 create mode 100644 test/e2e/app-dir/ppr-root-param-fallback/next.config.js
 create mode 100644 test/e2e/app-dir/ppr-root-param-fallback/ppr-root-param-fallback.test.ts

diff --git a/packages/next/errors.json b/packages/next/errors.json
index e9b2e658d8ff46..32c6553b435829 100644
--- a/packages/next/errors.json
+++ b/packages/next/errors.json
@@ -979,5 +979,6 @@
   "978": "Next.js has blocked a javascript: URL as a security precaution.",
   "979": "invariant: expected %s bytes of postponed state but only received %s bytes",
   "980": "Failed to load client middleware manifest",
-  "981": "resolvedPathname must be set in request metadata"
+  "981": "resolvedPathname must be set in request metadata",
+  "982": "`serializeResumeDataCache` should not be called in edge runtime."
 }
diff --git a/packages/next/src/export/index.ts b/packages/next/src/export/index.ts
index 3d317196ddd30f..418917b3a76ab8 100644
--- a/packages/next/src/export/index.ts
+++ b/packages/next/src/export/index.ts
@@ -69,11 +69,125 @@ import type { ActionManifest } from '../build/webpack/plugins/flight-client-entr
 import { extractInfoFromServerReferenceId } from '../shared/lib/server-reference-info'
 import { convertSegmentPathToStaticExportFilename } from '../shared/lib/segment-cache/segment-value-encoding'
 import { getNextBuildDebuggerPortOffset } from '../lib/worker'
+import { getParams } from './helpers/get-params'
+import { isDynamicRoute } from '../shared/lib/router/utils/is-dynamic'
+import { normalizeAppPath } from '../shared/lib/router/utils/app-paths'
+import type { Params } from '../server/request/params'
 
 export class ExportError extends Error {
   code = 'NEXT_EXPORT_ERROR'
 }
 
+/**
+ * Picks an RDC seed by matching on the params that are
+ * already known, so fallback shells use a seed that has already
+ * computed those known params.
+ */
+function buildRDCCacheByPage(
+  results: ExportPagesResult,
+  finalPhaseExportPaths: ExportPathEntry[]
+): Record<string, string> {
+  const renderResumeDataCachesByPage: Record<string, string> = {}
+  const seedCandidatesByPage = new Map<
+    string,
+    Array<{ path: string; renderResumeDataCache: string }>
+  >()
+
+  for (const { page, path, result } of results) {
+    if (!result) {
+      continue
+    }
+
+    if ('renderResumeDataCache' in result && result.renderResumeDataCache) {
+      // Collect all RDC seeds for this page so we can pick the best match
+      // for each fallback shell later (e.g. locale-specific variants).
+      const candidates = seedCandidatesByPage.get(page) ?? []
+      candidates.push({
+        path,
+        renderResumeDataCache: result.renderResumeDataCache,
+      })
+      seedCandidatesByPage.set(page, candidates)
+      // Remove the RDC string from the result so that it can be garbage
+      // collected, when there are more results for the same page.
+      result.renderResumeDataCache = undefined
+    }
+  }
+
+  const getKnownParamsKey = (
+    normalizedPage: string,
+    path: string,
+    fallbackParamNames: Set<string>
+  ): string | null => {
+    let params: Params
+    try {
+      params = getParams(normalizedPage, path)
+    } catch {
+      return null
+    }
+
+    // Only keep params that are known, then sort
+    // for a stable key so we can match a compatible seed.
+    const entries = Object.entries(params).filter(
+      ([key]) => !fallbackParamNames.has(key)
+    )
+
+    entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    return JSON.stringify(entries)
+  }
+
+  for (const exportPath of finalPhaseExportPaths) {
+    const { page, path, _fallbackRouteParams = [] } = exportPath
+    if (!isDynamicRoute(page)) {
+      continue
+    }
+
+    // Normalize app pages before param matching.
+    const normalizedPage = normalizeAppPath(page)
+    const pageKey = page !== path ? `${page}: ${path}` : path
+    const fallbackParamNames = new Set(
+      _fallbackRouteParams.map((param) => param.paramName)
+    )
+    // Build a key from the known params for this fallback shell so we can
+    // select a seed from a compatible prerendered route.
+    const targetKey = getKnownParamsKey(
+      normalizedPage,
+      path,
+      fallbackParamNames
+    )
+
+    if (!targetKey) {
+      continue
+    }
+
+    const candidates = seedCandidatesByPage.get(page)
+
+    // No suitable candidates, so there's no RDC seed to select
+    if (!candidates || candidates.length === 0) {
+      continue
+    }
+
+    let selected: string | null = null
+    for (const candidate of candidates) {
+      // Pick the seed whose known params match this fallback shell.
+      const candidateKey = getKnownParamsKey(
+        normalizedPage,
+        candidate.path,
+        fallbackParamNames
+      )
+      if (candidateKey === targetKey) {
+        selected = candidate.renderResumeDataCache
+        break
+      }
+    }
+
+    if (selected) {
+      renderResumeDataCachesByPage[pageKey] = selected
+    }
+  }
+
+  return renderResumeDataCachesByPage
+}
+
 async function exportAppImpl(
   dir: string,
   options: Readonly<ExportAppOptions>,
@@ -664,23 +778,10 @@ async function exportAppImpl(
     results = await exportPagesInBatches(worker, initialPhaseExportPaths)
 
     if (finalPhaseExportPaths.length > 0) {
-      const renderResumeDataCachesByPage: Record<string, string> = {}
-
-      for (const { page, result } of results) {
-        if (!result) {
-          continue
-        }
-
-        if ('renderResumeDataCache' in result && result.renderResumeDataCache) {
-          // The last RDC for each page is used. We only need one. It should have
-          // all the entries that the fallback shell also needs. We don't need to
-          // merge them per page.
-          renderResumeDataCachesByPage[page] = result.renderResumeDataCache
-          // Remove the RDC string from the result so that it can be garbage
-          // collected, when there are more results for the same page.
-          result.renderResumeDataCache = undefined
-        }
-      }
+      const renderResumeDataCachesByPage = buildRDCCacheByPage(
+        results,
+        finalPhaseExportPaths
+      )
 
       const finalPhaseResults = await exportPagesInBatches(
         worker,
diff --git a/packages/next/src/export/worker.ts b/packages/next/src/export/worker.ts
index 427afc0fe04a0c..a58ff9a73bf3d3 100644
--- a/packages/next/src/export/worker.ts
+++ b/packages/next/src/export/worker.ts
@@ -388,9 +388,9 @@ export async function exportPages(
       // Also tests for `inspect-brk`
       process.env.NODE_OPTIONS?.includes('--inspect')
 
-    const renderResumeDataCache = renderResumeDataCachesByPage[page]
+    const renderResumeDataCache = renderResumeDataCachesByPage[pageKey]
       ? createRenderResumeDataCache(
-          renderResumeDataCachesByPage[page],
+          renderResumeDataCachesByPage[pageKey],
           renderOpts.experimental.maxPostponedStateSizeBytes
         )
       : undefined
diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
index 314156cad84b8f..87db2a8e202b83 100644
--- a/packages/next/src/server/app-render/app-render.tsx
+++ b/packages/next/src/server/app-render/app-render.tsx
@@ -4276,22 +4276,11 @@ async function prerenderToStream(
       // to cut the render off.
       const cacheSignal = new CacheSignal()
 
-      let resumeDataCache: RenderResumeDataCache | PrerenderResumeDataCache
-      let renderResumeDataCache: RenderResumeDataCache | null = null
-      let prerenderResumeDataCache: PrerenderResumeDataCache | null = null
-
-      if (renderOpts.renderResumeDataCache) {
-        // If a prefilled immutable render resume data cache is provided, e.g.
-        // when prerendering an optional fallback shell after having prerendered
-        // pages with defined params, we use this instead of a prerender resume
-        // data cache.
-        resumeDataCache = renderResumeDataCache =
-          renderOpts.renderResumeDataCache
-      } else {
-        // Otherwise we create a new mutable prerender resume data cache.
-        resumeDataCache = prerenderResumeDataCache =
-          createPrerenderResumeDataCache()
-      }
+      // Always start with a fresh prerender RDC so warmup can fill misses,
+      // even when we have a prefilled render RDC to seed from.
+      const prerenderResumeDataCache = createPrerenderResumeDataCache()
+      let renderResumeDataCache: RenderResumeDataCache | null =
+        renderOpts.renderResumeDataCache ?? null
 
       const initialServerPayloadPrerenderStore: PrerenderStore = {
         type: 'prerender',
@@ -4561,6 +4550,13 @@ async function prerenderToStream(
         initialClientReactController.abort()
       }
 
+      if (renderOpts.renderResumeDataCache) {
+        // Swap to the warmed cache so the final render uses entries produced during warmup.
+        renderResumeDataCache = createRenderResumeDataCache(
+          prerenderResumeDataCache
+        )
+      }
+
       const finalServerReactController = new AbortController()
       const finalServerRenderController = new AbortController()
 
@@ -4827,13 +4823,13 @@ async function prerenderToStream(
               ? DynamicHTMLPreludeState.Empty
               : DynamicHTMLPreludeState.Full,
             fallbackRouteParams,
-            resumeDataCache,
+            prerenderResumeDataCache,
             cacheComponents
           )
         } else {
           // Dynamic Data case
           metadata.postponed = await getDynamicDataPostponedState(
-            resumeDataCache,
+            prerenderResumeDataCache,
             cacheComponents
           )
         }
@@ -4855,7 +4851,9 @@ async function prerenderToStream(
           collectedExpire: finalServerPrerenderStore.expire,
           collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
           collectedTags: finalServerPrerenderStore.tags,
-          renderResumeDataCache: createRenderResumeDataCache(resumeDataCache),
+          renderResumeDataCache: createRenderResumeDataCache(
+            prerenderResumeDataCache
+          ),
         }
       } else {
         // Static case
@@ -4972,7 +4970,9 @@ async function prerenderToStream(
           collectedExpire: finalServerPrerenderStore.expire,
           collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
           collectedTags: finalServerPrerenderStore.tags,
-          renderResumeDataCache: createRenderResumeDataCache(resumeDataCache),
+          renderResumeDataCache: createRenderResumeDataCache(
+            prerenderResumeDataCache
+          ),
         }
       }
     } else if (experimental.isRoutePPREnabled) {
diff --git a/packages/next/src/server/use-cache/use-cache-wrapper.ts b/packages/next/src/server/use-cache/use-cache-wrapper.ts
index 7c207ae5ec90c7..6c60c3459432be 100644
--- a/packages/next/src/server/use-cache/use-cache-wrapper.ts
+++ b/packages/next/src/server/use-cache/use-cache-wrapper.ts
@@ -620,7 +620,6 @@ async function generateCacheEntryImpl(
     case 'prerender-runtime':
     case 'prerender':
       const timeoutAbortController = new AbortController()
-
       // If we're prerendering, we give you 50 seconds to fill a cache entry.
       // Otherwise we assume you stalled on hanging input and de-opt. This needs
       // to be lower than just the general timeout of 60 seconds.
@@ -1385,6 +1384,10 @@ export async function cache(
       if (existingEntry !== undefined) {
         debug?.('Resume Data Cache entry found', serializedCacheKey)
 
+        if (prerenderResumeDataCache) {
+          prerenderResumeDataCache.cache.set(serializedCacheKey, cachedEntry)
+        }
+
         // We want to make sure we only propagate cache life & tags if the
         // entry was *not* omitted from the prerender. So we only do this
         // after the above early returns.
diff --git a/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/blog/[slug]/page.tsx b/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/blog/[slug]/page.tsx
new file mode 100644
index 00000000000000..cd416dc42d765c
--- /dev/null
+++ b/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/blog/[slug]/page.tsx
@@ -0,0 +1,78 @@
+import { Suspense } from 'react'
+import { cookies } from 'next/headers'
+import Link from 'next/link'
+
+async function getBlogPost(locale: string, slug: string) {
+  'use cache'
+  await new Promise((resolve) => setTimeout(resolve, 700))
+  return {
+    title: `Blog Post: ${slug}`,
+    locale,
+    content: 'This content was fetched from the CMS...',
+    relatedPosts: ['Related Post 1', 'Related Post 2', 'Related Post 3'],
+  }
+}
+
+export default async function BlogPost({
+  params,
+}: {
+  params: Promise<{ locale: string; slug: string }>
+}) {
+  return (
+    <main>
+      <div id="static-blog-header">Blog Article</div>
+      <div id="static-reading-time">Estimated reading time: 5 minutes</div>
+
+      <Suspense fallback={<div id="blog-loading">Loading article...</div>}>
+        <BlogContent params={params} />
+      </Suspense>
+
+      <Suspense fallback={<div id="dynamic-loading">Loading comments...</div>}>
+        <DynamicComments />
+      </Suspense>
+    </main>
+  )
+}
+
+// This component depends on locale and slug, so it's in Suspense
+async function BlogContent({
+  params,
+}: {
+  params: Promise<{ locale: string; slug: string }>
+}) {
+  const { locale, slug } = await params
+  const post = await getBlogPost(locale, slug)
+  return (
+    <>
+      <article id="blog-content">
+        <h1>{post.title}</h1>
+        <p>Locale: {post.locale}</p>
+        <p>{post.content}</p>
+      </article>
+      <aside id="related-posts">
+        <h2>Related Posts ({post.locale})</h2>
+        <ul>
+          {post.relatedPosts.map((title, i) => (
+            <li key={i}>
+              <Link href={`/en/blog/${i}`}>{title}</Link>
+            </li>
+          ))}
+        </ul>
+      </aside>
+    </>
+  )
+}
+
+async function DynamicComments() {
+  const cookieStore = await cookies()
+  const user = cookieStore.get('user')?.value || 'anonymous'
+  return (
+    <section id="comments">
+      <h3>Comments</h3>
+      <p>Viewing as: {user}</p>
+    </section>
+  )
+}
+export function generateStaticParams() {
+  return [{ slug: 'hello-world' }, { slug: 'getting-started' }]
+}
diff --git a/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/layout.tsx b/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/layout.tsx
new file mode 100644
index 00000000000000..4c55fb68d78c5e
--- /dev/null
+++ b/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/layout.tsx
@@ -0,0 +1,76 @@
+import { Suspense } from 'react'
+import { cookies } from 'next/headers'
+
+async function getLocaleConfig(localeParam: string) {
+  'use cache'
+  await new Promise((resolve) => setTimeout(resolve, 800))
+  return {
+    locale: localeParam,
+    translations: {
+      home: `Home (${localeParam})`,
+      blog: `Blog (${localeParam})`,
+      about: `About (${localeParam})`,
+    },
+  }
+}
+
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode
+  params: Promise<{ locale: string }>
+}) {
+  return (
+    <html>
+      <body>
+        <div id="static-header">Welcome to our Blog Platform</div>
+        <nav id="static-nav">
+          <ul>
+            <li>Home</li>
+            <li>Blog</li>
+            <li>About</li>
+          </ul>
+        </nav>
+
+        <Suspense
+          fallback={<div id="locale-loading">Loading locale info...</div>}
+        >
+          <LocaleInfo params={params} />
+        </Suspense>
+
+        <Suspense fallback={<div id="dynamic-loading">Loading user...</div>}>
+          <UserInfo />
+        </Suspense>
+
+        {children}
+      </body>
+    </html>
+  )
+}
+
+// This component depends on locale, so it's in Suspense
+async function LocaleInfo({ params }: { params: Promise<{ locale: string }> }) {
+  const { locale } = await params
+  const config = await getLocaleConfig(locale)
+
+  return (
+    <header id="locale-header">
+      <span>Locale: {config.locale}</span>
+      <div id="translations">
+        {config.translations.home} | {config.translations.blog} |{' '}
+        {config.translations.about}
+      </div>
+    </header>
+  )
+}
+
+async function UserInfo() {
+  const cookieStore = await cookies()
+  const user = cookieStore.get('user')?.value || 'anonymous'
+  return <div id="user-info">Logged in as: {user}</div>
+}
+
+export function generateStaticParams() {
+  return [{ locale: 'en' }, { locale: 'fr' }]
+}
diff --git a/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/page.tsx b/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/page.tsx
new file mode 100644
index 00000000000000..f5ec620189f64e
--- /dev/null
+++ b/test/e2e/app-dir/ppr-root-param-fallback/app/[locale]/page.tsx
@@ -0,0 +1,10 @@
+export default function Home() {
+  return (
+    <main>
+      <div id="home-content">
+        <h1>Home</h1>
+        <p>Welcome!</p>
+      </div>
+    </main>
+  )
+}
diff --git a/test/e2e/app-dir/ppr-root-param-fallback/next.config.js b/test/e2e/app-dir/ppr-root-param-fallback/next.config.js
new file mode 100644
index 00000000000000..e64bae22d65803
--- /dev/null
+++ b/test/e2e/app-dir/ppr-root-param-fallback/next.config.js
@@ -0,0 +1,8 @@
+/**
+ * @type {import('next').NextConfig}
+ */
+const nextConfig = {
+  cacheComponents: true,
+}
+
+module.exports = nextConfig
diff --git a/test/e2e/app-dir/ppr-root-param-fallback/ppr-root-param-fallback.test.ts b/test/e2e/app-dir/ppr-root-param-fallback/ppr-root-param-fallback.test.ts
new file mode 100644
index 00000000000000..e29b7fd25747e8
--- /dev/null
+++ b/test/e2e/app-dir/ppr-root-param-fallback/ppr-root-param-fallback.test.ts
@@ -0,0 +1,30 @@
+import { nextTestSetup } from 'e2e-utils'
+
+describe('ppr-root-param-fallback', () => {
+  const { next } = nextTestSetup({
+    files: __dirname,
+  })
+
+  it('should have use-cache content in fallback shells for all pregenerated locales', async () => {
+    // Setup: The app has a [locale] param with generateStaticParams returning
+    // ['en', 'fr'], and a nested /[locale]/blog/[slug] route. The layout uses
+    // a 'use cache' function to fetch locale-specific translations.
+    //
+    // This test ensures that we generate fallback shells with the correct locale
+    // filled in for all pregenerated locales.
+
+    for (const locale of ['en', 'fr']) {
+      // next.render$ doesn't stream, so we get just the shell content
+      const $ = await next.render$(`/${locale}/blog/new-post`)
+
+      // The shell should have the locale-header with cached content,
+      // NOT the locale-loading Suspense fallback
+      expect($('#locale-header').length).toBe(1)
+      expect($('#locale-header').text()).toContain(`Locale: ${locale}`)
+      expect($('#translations').text()).toContain(`Home (${locale})`)
+
+      // The Suspense fallback should NOT be in the shell
+      expect($('#locale-loading').length).toBe(0)
+    }
+  })
+})

From d23af53268d062ff70b7c12322750b85ed3a76ba Mon Sep 17 00:00:00 2001
From: Matt Mastracci <matthew@mastracci.com>
Date: Wed, 21 Jan 2026 10:08:54 -0700
Subject: [PATCH 6/8] Turbopack: Use a real file entrypoint for Workers (and
 SharedWorkers) (#88602)

# What

Closes https://github.com/vercel/next.js/issues/84782
Closes https://github.com/vercel/next.js/issues/74842
Closes https://github.com/vercel/next.js/issues/82520
Closes PACK-3723

Replace blob URLs for web workers with real entrypoint files, fixing relative URL resolution inside workers. Implements support for `SharedWorkers` since it's now a simple variation of the `Worker` case.

Note that all generated files (and shared-worker querystrings) are appropriately content-hashed and do not rely on deployment IDs and will work w/immutable resources.

# Why

Workers created via `new Worker(new URL('./worker.js', import.meta.url))` previously got blob URLs. This breaks relative URL resolution inside workers - WASM imports like `new URL('./file.wasm', import.meta.url)` fail because `import.meta.url` returns `blob:http://...` instead of a real path.

# How

We emit a real worker entrypoint file instead of blob URLs. The entrypoint reads bootstrap config from URL hash params (`#params=....`), then loads the worker's chunks via `importScripts`.

The `ChunkingContext` trait gets a new `worker_entrypoint()` method returning a singleton bootstrap asset. Node.js `bail!`s for now but could implement its own in the future. The browser implementation (`EcmascriptBrowserWorkerEntrypoint`) compiles and minifies `worker-entrypoint.ts`, which parses `#params={globals,chunks}` from the URL at runtime.

`WorkerLoaderChunkItem` now emits `__turbopack_worker_url__(entrypoint, chunks, shared)` instead of the old blob URL shim. SharedWorker passes `shared=true` which adds a querystring - the browser handles worker identity via URL, so same URL means same instance.

Generated code changes (pseudocode):

```javascript
__turbopack_export_value__(__turbopack_worker_blob_url__(["chunk1.js", "chunk2.js"]));
```

After:

```javascript
__turbopack_export_value__(__turbopack_worker_url__("worker-entrypoint.js", ["chunk1.js", "chunk2.js"], false));
```

# Notes

Webpack doesn't currently correctly support `SharedWorkers`. The e2e test behaves properly in turbopack after this change, but webpack spins up two separate workers where it should only be spinning up one.

I generated snapshot tests for workers in the first and last commits to help understand the generated code better.

# Testing

- Snapshot tests for Worker, SharedWorker, and minified output
- E2E tests for WASM loading in workers (`test/e2e/app-dir/worker/`)
---
 test/e2e/app-dir/worker/app/add.wasm          |  Bin 0 -> 126 bytes
 test/e2e/app-dir/worker/app/shared-worker.ts  |    8 +
 test/e2e/app-dir/worker/app/shared/page.js    |   39 +
 test/e2e/app-dir/worker/app/wasm-worker.ts    |   22 +
 test/e2e/app-dir/worker/app/wasm/page.js      |   27 +
 test/e2e/app-dir/worker/worker.test.ts        |   37 +-
 .../turbopack-browser/src/chunking_context.rs |   13 +
 .../turbopack-browser/src/ecmascript/mod.rs   |    2 +
 .../src/ecmascript/worker.rs                  |  132 ++
 .../src/chunk/chunking_context.rs             |   16 +-
 turbopack/crates/turbopack-core/src/output.rs |   31 +-
 .../crates/turbopack-core/src/resolve/mod.rs  |    2 +-
 .../src/browser/runtime/base/runtime-base.ts  |   48 +-
 .../browser/runtime/base/worker-entrypoint.ts |   81 +
 .../runtime/dom/runtime-backend-dom.ts        |    2 +-
 .../js/src/nodejs/runtime.ts                  |   10 +-
 .../js/src/shared/runtime-types.d.ts          |    8 +-
 .../src/browser_runtime.rs                    |   12 +
 .../turbopack-ecmascript-runtime/src/lib.rs   |    2 +-
 .../turbopack-ecmascript/src/analyzer/mod.rs  |    5 +
 .../src/references/mod.rs                     |   27 +-
 .../src/references/worker.rs                  |   16 +-
 .../src/runtime_functions.rs                  |    4 +-
 .../src/worker_chunk/chunk_item.rs            |   43 +-
 .../src/worker_chunk/module.rs                |   27 +-
 .../crates/turbopack-tests/tests/snapshot.rs  |   17 +-
 ...ug-ids_browser_input_index_0151fefb.js.map |   10 +-
 ..._debug-ids_browser_input_index_0151fefb.js |   47 +-
 .../node/output/[turbopack]_runtime.js        |    6 +-
 .../node/output/[turbopack]_runtime.js.map    |    2 +-
 ...ports_ignore-comments_output_2867ca5f._.js |   62 +
 ...mports_ignore-comments_input_1f8151c3._.js |    5 +-
 ...ts_ignore-comments_input_1f8151c3._.js.map |    2 +-
 ...s_ignore-comments_output_2867ca5f._.js.map |    1 +
 .../output/[turbopack]_runtime.js             |    6 +-
 .../output/[turbopack]_runtime.js.map         |    2 +-
 ...efault_dev_runtime_input_index_c0f7e0b0.js |   43 +-
 ...lt_dev_runtime_input_index_c0f7e0b0.js.map |    8 +-
 ...nsforms_preset_env_input_index_5aaf1327.js |   45 +-
 ...rms_preset_env_input_index_5aaf1327.js.map |    6 +-
 .../snapshot/workers/basic/input/index.js     |    3 +
 .../snapshot/workers/basic/input/worker.js    |    2 +
 .../tests/snapshot/workers/basic/options.json |    6 +
 ...napshot_workers_basic_output_2867ca5f._.js |   62 +
 ..._workers_basic_input_index_96b0ffc6.js.map |   10 +
 ...workers_basic_input_worker_01a12aa6.js.map |   10 +
 ...hot_workers_basic_input_worker_841f9693.js |    9 +
 ...workers_basic_input_worker_841f9693.js.map |    6 +
 ...shot_workers_basic_input_index_96b0ffc6.js | 1869 +++++++++++++++++
 ...hot_workers_basic_input_worker_01a12aa6.js | 1869 +++++++++++++++++
 ...snapshot_workers_basic_input_73fc86c5._.js |   22 +
 ...shot_workers_basic_input_73fc86c5._.js.map |    6 +
 ...hot_workers_basic_output_2867ca5f._.js.map |    1 +
 .../workers/basic/static/worker.60655f93.js   |    2 +
 .../snapshot/workers/shared/input/index.js    |    2 +
 .../snapshot/workers/shared/input/worker.js   |    1 +
 .../snapshot/workers/shared/options.json      |    6 +
 ...apshot_workers_shared_output_2867ca5f._.js |   62 +
 ...workers_shared_input_index_818b7886.js.map |   10 +
 ...orkers_shared_input_worker_87533493.js.map |   10 +
 ...ot_workers_shared_input_worker_e14430d8.js |    8 +
 ...orkers_shared_input_worker_e14430d8.js.map |    6 +
 ...hot_workers_shared_input_index_818b7886.js | 1869 +++++++++++++++++
 ...ot_workers_shared_input_worker_87533493.js | 1869 +++++++++++++++++
 ...napshot_workers_shared_input_3845375a._.js |   21 +
 ...hot_workers_shared_input_3845375a._.js.map |    6 +
 ...ot_workers_shared_output_2867ca5f._.js.map |    1 +
 .../workers/shared/static/worker.35b5336b.js  |    1 +
 68 files changed, 8476 insertions(+), 149 deletions(-)
 create mode 100755 test/e2e/app-dir/worker/app/add.wasm
 create mode 100644 test/e2e/app-dir/worker/app/shared-worker.ts
 create mode 100644 test/e2e/app-dir/worker/app/shared/page.js
 create mode 100644 test/e2e/app-dir/worker/app/wasm-worker.ts
 create mode 100644 test/e2e/app-dir/worker/app/wasm/page.js
 create mode 100644 turbopack/crates/turbopack-browser/src/ecmascript/worker.rs
 create mode 100644 turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/worker-entrypoint.ts
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/6642e_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/options.json
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/6642e_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/static/worker.60655f93.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/options.json
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/6642e_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js.map
 create mode 100644 turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/static/worker.35b5336b.js

diff --git a/test/e2e/app-dir/worker/app/add.wasm b/test/e2e/app-dir/worker/app/add.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..f22496d0b6c87704a3844134af2a9fad47fa344c
GIT binary patch
literal 126
zcmY+)F%E)25CzcxcYuwog{_@8@C=+}7_*ZYlLaC+R?E>mnzU4}d9bw*08e2AMpjml
z05&ZblC2Pz?kbhTw*8PQj>db_6)*Gq8<13=Zi_x_bz!fX?PKawmJlsxohJwTbJ%CZ
I4Fg~44-%gmga7~l

literal 0
HcmV?d00001

diff --git a/test/e2e/app-dir/worker/app/shared-worker.ts b/test/e2e/app-dir/worker/app/shared-worker.ts
new file mode 100644
index 00000000000000..622ffcbdbb2b70
--- /dev/null
+++ b/test/e2e/app-dir/worker/app/shared-worker.ts
@@ -0,0 +1,8 @@
+// SharedWorkers use onconnect to handle incoming connections
+let count = 0
+self.addEventListener('connect', function (e: MessageEvent) {
+  const port = e.ports[0]
+  import('./worker-dep').then((mod) => {
+    port.postMessage('shared-worker.ts:' + mod.default + ':' + ++count)
+  })
+})
diff --git a/test/e2e/app-dir/worker/app/shared/page.js b/test/e2e/app-dir/worker/app/shared/page.js
new file mode 100644
index 00000000000000..f302b72bc6b4bd
--- /dev/null
+++ b/test/e2e/app-dir/worker/app/shared/page.js
@@ -0,0 +1,39 @@
+'use client'
+import { useState } from 'react'
+
+export default function Home() {
+  const [state, setState] = useState('default')
+  return (
+    <div>
+      <button
+        onClick={() => {
+          const worker = new SharedWorker(
+            new URL('../shared-worker', import.meta.url),
+            {
+              type: 'module',
+            }
+          )
+          worker.port.addEventListener('message', (event) => {
+            setState(event.data)
+            // Run a second time, which will use the same worker
+            const worker = new SharedWorker(
+              new URL('../shared-worker', import.meta.url),
+              {
+                type: 'module',
+              }
+            )
+            worker.port.addEventListener('message', (event) => {
+              setState(event.data)
+            })
+            worker.port.start()
+          })
+          worker.port.start()
+        }}
+      >
+        Get web worker data
+      </button>
+      <p>Worker state: </p>
+      <p id="worker-state">{state}</p>
+    </div>
+  )
+}
diff --git a/test/e2e/app-dir/worker/app/wasm-worker.ts b/test/e2e/app-dir/worker/app/wasm-worker.ts
new file mode 100644
index 00000000000000..4c64dce1a6ac5e
--- /dev/null
+++ b/test/e2e/app-dir/worker/app/wasm-worker.ts
@@ -0,0 +1,22 @@
+// This worker tries to load WASM using a relative URL to ensure that
+// `import.meta.url` returns a URL valid for relative URL resolution.
+
+async function loadWasm() {
+  try {
+    // This is the pattern that fails with blob URLs
+    const wasmUrl = new URL('./add.wasm', import.meta.url)
+    const response = await fetch(wasmUrl)
+    const wasmBuffer = await response.arrayBuffer()
+    const wasmModule = await WebAssembly.instantiate(wasmBuffer)
+    const addOne = wasmModule.instance.exports.add_one as (n: number) => number
+    const result = addOne(41)
+    self.postMessage({ success: true, result })
+  } catch (error) {
+    self.postMessage({
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+loadWasm()
diff --git a/test/e2e/app-dir/worker/app/wasm/page.js b/test/e2e/app-dir/worker/app/wasm/page.js
new file mode 100644
index 00000000000000..0faa437e3d7118
--- /dev/null
+++ b/test/e2e/app-dir/worker/app/wasm/page.js
@@ -0,0 +1,27 @@
+'use client'
+import { useState } from 'react'
+
+export default function WasmWorkerPage() {
+  const [state, setState] = useState('default')
+
+  return (
+    <div>
+      <button
+        onClick={() => {
+          const worker = new Worker(new URL('../wasm-worker', import.meta.url))
+          worker.addEventListener('message', (event) => {
+            if (event.data.success) {
+              setState(`result:${event.data.result}`)
+            } else {
+              setState(`error:${event.data.error}`)
+            }
+          })
+        }}
+      >
+        Load WASM in worker
+      </button>
+      <p>Worker state: </p>
+      <p id="worker-state">{state}</p>
+    </div>
+  )
+}
diff --git a/test/e2e/app-dir/worker/worker.test.ts b/test/e2e/app-dir/worker/worker.test.ts
index d323b619d659a9..5b6ede52e571cd 100644
--- a/test/e2e/app-dir/worker/worker.test.ts
+++ b/test/e2e/app-dir/worker/worker.test.ts
@@ -17,7 +17,7 @@ describe('app dir - workers', () => {
       const url = request.url()
       // TODO fix deployment id for webpack
       if (isTurbopack) {
-        if (url.includes('_next')) {
+        if (url.includes('_next') && !url.includes('wasm')) {
           expect(url).toMatch(/^[^?]+\?(v=\d+&)?dpl=test-deployment-id$/)
         }
       }
@@ -96,4 +96,39 @@ describe('app dir - workers', () => {
       expect(workerDeploymentId).toBe('test-deployment-id')
     })
   })
+
+  it('should support loading WASM files in workers', async () => {
+    const browser = await next.browser('/wasm', {
+      beforePageLoad,
+    })
+    expect(await browser.elementByCss('#worker-state').text()).toBe('default')
+
+    await browser.elementByCss('button').click()
+
+    // The WASM add_one(41) should return 42
+    await retry(async () =>
+      expect(await browser.elementByCss('#worker-state').text()).toBe(
+        'result:42'
+      )
+    )
+  })
+
+  it('should support shared workers', async () => {
+    if (!isTurbopack) {
+      // webpack requires a magic attribute for shared workers to function
+      return
+    }
+    const browser = await next.browser('/shared', {
+      beforePageLoad,
+    })
+    expect(await browser.elementByCss('#worker-state').text()).toBe('default')
+
+    await browser.elementByCss('button').click()
+
+    await retry(async () =>
+      expect(await browser.elementByCss('#worker-state').text()).toBe(
+        'shared-worker.ts:worker-dep:2'
+      )
+    )
+  })
 })
diff --git a/turbopack/crates/turbopack-browser/src/chunking_context.rs b/turbopack/crates/turbopack-browser/src/chunking_context.rs
index fdffa939f593f5..0ca2d454fc918c 100644
--- a/turbopack/crates/turbopack-browser/src/chunking_context.rs
+++ b/turbopack/crates/turbopack-browser/src/chunking_context.rs
@@ -18,6 +18,7 @@ use turbopack_core::{
         chunk_group::{MakeChunkGroupResult, make_chunk_group},
         chunk_id_strategy::ModuleIdStrategy,
     },
+    context::AssetContext,
     environment::Environment,
     ident::AssetIdent,
     module::Module,
@@ -39,6 +40,7 @@ use crate::ecmascript::{
     chunk::EcmascriptBrowserChunk,
     evaluate::chunk::EcmascriptBrowserEvaluateChunk,
     list::asset::{EcmascriptDevChunkList, EcmascriptDevChunkListSource},
+    worker::EcmascriptBrowserWorkerEntrypoint,
 };
 
 #[turbo_tasks::value]
@@ -897,6 +899,17 @@ impl ChunkingContext for BrowserChunkingContext {
     async fn debug_ids_enabled(self: Vc<Self>) -> Result<Vc<bool>> {
         Ok(Vc::cell(self.await?.debug_ids))
     }
+
+    #[turbo_tasks::function]
+    fn worker_entrypoint(
+        self: Vc<Self>,
+        asset_context: Vc<Box<dyn AssetContext>>,
+    ) -> Vc<Box<dyn OutputAsset>> {
+        Vc::upcast(EcmascriptBrowserWorkerEntrypoint::new(
+            Vc::upcast(self),
+            asset_context,
+        ))
+    }
 }
 
 #[turbo_tasks::value]
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs b/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs
index 2d18d579d4ad16..d80b785e8ba643 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs
@@ -6,6 +6,8 @@ pub(crate) mod list;
 pub(crate) mod merged;
 pub(crate) mod update;
 pub(crate) mod version;
+pub(crate) mod worker;
 
 pub use chunk::EcmascriptBrowserChunk;
 pub use content::EcmascriptBrowserChunkContent;
+pub use worker::EcmascriptBrowserWorkerEntrypoint;
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/worker.rs b/turbopack/crates/turbopack-browser/src/ecmascript/worker.rs
new file mode 100644
index 00000000000000..6c99c183d75909
--- /dev/null
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/worker.rs
@@ -0,0 +1,132 @@
+use anyhow::Result;
+use turbo_rcstr::{RcStr, rcstr};
+use turbo_tasks::{ResolvedVc, ValueToString, Vc};
+use turbo_tasks_fs::{File, FileContent, FileSystemPath};
+use turbopack_core::{
+    asset::{Asset, AssetContent},
+    chunk::{ChunkingContext, MinifyType},
+    code_builder::Code,
+    context::AssetContext,
+    ident::AssetIdent,
+    output::{OutputAsset, OutputAssetsReference, OutputAssetsWithReferenced},
+    source_map::{GenerateSourceMap, SourceMapAsset},
+};
+use turbopack_ecmascript::minify::minify;
+use turbopack_ecmascript_runtime::get_worker_runtime_code;
+
+/// A pre-compiled worker entrypoint that bootstraps workers by reading config from URL params.
+/// The entrypoint is keyed by (chunking_context, asset_context) to ensure proper compilation.
+#[turbo_tasks::value(shared)]
+pub struct EcmascriptBrowserWorkerEntrypoint {
+    chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
+    asset_context: ResolvedVc<Box<dyn AssetContext>>,
+}
+
+#[turbo_tasks::value_impl]
+impl EcmascriptBrowserWorkerEntrypoint {
+    #[turbo_tasks::function]
+    pub async fn new(
+        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
+        asset_context: ResolvedVc<Box<dyn AssetContext>>,
+    ) -> Result<Vc<Self>> {
+        Ok(EcmascriptBrowserWorkerEntrypoint {
+            chunking_context,
+            asset_context,
+        }
+        .cell())
+    }
+
+    #[turbo_tasks::function]
+    async fn code(self: Vc<Self>) -> Result<Vc<Code>> {
+        let this = self.await?;
+
+        let source_maps = *this
+            .chunking_context
+            .reference_chunk_source_maps(Vc::upcast(self))
+            .await?;
+
+        let mut code = get_worker_runtime_code(*this.asset_context, source_maps)?
+            .owned()
+            .await?;
+
+        if let MinifyType::Minify { mangle } = *this.chunking_context.minify_type().await? {
+            code = minify(code, source_maps, mangle)?;
+        }
+
+        Ok(code.cell())
+    }
+
+    #[turbo_tasks::function]
+    async fn ident_for_path(&self) -> Result<Vc<AssetIdent>> {
+        let chunk_root_path = self.chunking_context.chunk_root_path().owned().await?;
+        let ident = AssetIdent::from_path(chunk_root_path)
+            .with_modifier(rcstr!("turbopack worker entrypoint"));
+        Ok(ident)
+    }
+
+    #[turbo_tasks::function]
+    async fn source_map(self: Vc<Self>) -> Result<Vc<SourceMapAsset>> {
+        let this = self.await?;
+        Ok(SourceMapAsset::new(
+            *this.chunking_context,
+            self.ident_for_path(),
+            Vc::upcast(self),
+        ))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl ValueToString for EcmascriptBrowserWorkerEntrypoint {
+    #[turbo_tasks::function]
+    fn to_string(&self) -> Vc<RcStr> {
+        Vc::cell(rcstr!("Ecmascript Browser Worker Entrypoint"))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl OutputAssetsReference for EcmascriptBrowserWorkerEntrypoint {
+    #[turbo_tasks::function]
+    async fn references(self: Vc<Self>) -> Result<Vc<OutputAssetsWithReferenced>> {
+        Ok(OutputAssetsWithReferenced::from_assets(Vc::cell(vec![
+            ResolvedVc::upcast(self.source_map().to_resolved().await?),
+        ])))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl OutputAsset for EcmascriptBrowserWorkerEntrypoint {
+    #[turbo_tasks::function]
+    async fn path(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
+        let this = self.await?;
+        let ident = self.ident_for_path();
+        Ok(this.chunking_context.chunk_path(
+            Some(Vc::upcast(self)),
+            ident,
+            Some(rcstr!("turbopack-worker")),
+            rcstr!(".js"),
+        ))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl Asset for EcmascriptBrowserWorkerEntrypoint {
+    #[turbo_tasks::function]
+    async fn content(self: Vc<Self>) -> Result<Vc<AssetContent>> {
+        Ok(AssetContent::file(
+            FileContent::Content(File::from(
+                self.code()
+                    .to_rope_with_magic_comments(|| self.source_map())
+                    .await?,
+            ))
+            .cell(),
+        ))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl GenerateSourceMap for EcmascriptBrowserWorkerEntrypoint {
+    #[turbo_tasks::function]
+    fn generate_source_map(self: Vc<Self>) -> Vc<FileContent> {
+        self.code().generate_source_map()
+    }
+}
diff --git a/turbopack/crates/turbopack-core/src/chunk/chunking_context.rs b/turbopack/crates/turbopack-core/src/chunk/chunking_context.rs
index 08f397a0ced4ab..1849276b252a04 100644
--- a/turbopack/crates/turbopack-core/src/chunk/chunking_context.rs
+++ b/turbopack/crates/turbopack-core/src/chunk/chunking_context.rs
@@ -13,6 +13,7 @@ use crate::{
         ChunkItem, ChunkType, ChunkableModule, EvaluatableAssets,
         availability_info::AvailabilityInfo, chunk_id_strategy::ModuleIdStrategy,
     },
+    context::AssetContext,
     environment::Environment,
     ident::AssetIdent,
     module::Module,
@@ -444,8 +445,21 @@ pub trait ChunkingContext {
     /// Returns whether debug IDs are enabled for this chunking context.
     #[turbo_tasks::function]
     fn debug_ids_enabled(self: Vc<Self>) -> Vc<bool>;
-}
 
+    /// Returns the worker entrypoint for this chunking context.
+    /// The asset_context should come from the origin where the worker was created.
+    #[turbo_tasks::function]
+    async fn worker_entrypoint(
+        self: Vc<Self>,
+        asset_context: Vc<Box<dyn AssetContext>>,
+    ) -> Result<Vc<Box<dyn OutputAsset>>> {
+        let _ = asset_context;
+        bail!(
+            "Worker entrypoint is not supported by {name}",
+            name = self.name().await?
+        );
+    }
+}
 pub trait ChunkingContextExt {
     fn root_chunk_group(
         self: Vc<Self>,
diff --git a/turbopack/crates/turbopack-core/src/output.rs b/turbopack/crates/turbopack-core/src/output.rs
index e3999b07f02a4b..f6368badf2e3fe 100644
--- a/turbopack/crates/turbopack-core/src/output.rs
+++ b/turbopack/crates/turbopack-core/src/output.rs
@@ -82,6 +82,13 @@ impl OutputAssets {
         Ok(Vc::cell(assets.into_iter().collect()))
     }
 
+    #[turbo_tasks::function]
+    pub async fn concat_asset(&self, asset: ResolvedVc<Box<dyn OutputAsset>>) -> Result<Vc<Self>> {
+        let mut assets: FxIndexSet<_> = self.0.iter().copied().collect();
+        assets.extend([asset]);
+        Ok(Vc::cell(assets.into_iter().collect()))
+    }
+
     #[turbo_tasks::function]
     pub async fn concat(other: Vec<Vc<Self>>) -> Result<Vc<Self>> {
         let mut assets: FxIndexSet<_> = FxIndexSet::default();
@@ -161,26 +168,36 @@ impl OutputAssetsWithReferenced {
 
     #[turbo_tasks::function]
     pub async fn concatenate(&self, other: Vc<Self>) -> Result<Vc<Self>> {
+        let other = other.await?;
         Ok(Self {
-            assets: self
-                .assets
-                .concatenate(*other.await?.assets)
-                .to_resolved()
-                .await?,
+            assets: self.assets.concatenate(*other.assets).to_resolved().await?,
             referenced_assets: self
                 .referenced_assets
-                .concatenate(*other.await?.referenced_assets)
+                .concatenate(*other.referenced_assets)
                 .to_resolved()
                 .await?,
             references: self
                 .references
-                .concatenate(*other.await?.references)
+                .concatenate(*other.references)
                 .to_resolved()
                 .await?,
         }
         .cell())
     }
 
+    #[turbo_tasks::function]
+    pub async fn concatenate_asset(
+        &self,
+        asset: ResolvedVc<Box<dyn OutputAsset>>,
+    ) -> Result<Vc<Self>> {
+        Ok(Self {
+            assets: self.assets.concat_asset(*asset).to_resolved().await?,
+            referenced_assets: self.referenced_assets,
+            references: self.references,
+        }
+        .cell())
+    }
+
     /// Returns all assets, including referenced assets and nested assets.
     #[turbo_tasks::function]
     pub async fn expand_all_assets(&self) -> Result<Vc<ExpandedOutputAssets>> {
diff --git a/turbopack/crates/turbopack-core/src/resolve/mod.rs b/turbopack/crates/turbopack-core/src/resolve/mod.rs
index cf522ece52dbf2..c531ca48df6e88 100644
--- a/turbopack/crates/turbopack-core/src/resolve/mod.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/mod.rs
@@ -480,7 +480,7 @@ pub enum ResolveResultItem {
 /// resolving.
 ///
 /// A primary factor is the actual request string, but there are
-/// other factors like exports conditions that can affect resolting and become
+/// other factors like exports conditions that can affect resolving and become
 /// part of the key (assuming the condition is unknown at compile time)
 #[derive(Clone, Debug, Default, Hash, TaskInput)]
 #[turbo_tasks::value]
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
index 4ad94bb61df962..84d1bfafd9b5e3 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
@@ -11,12 +11,11 @@
 /// <reference path="../base/globals.d.ts" />
 /// <reference path="../../../shared/runtime-utils.ts" />
 
-// Used in WebWorkers to tell the runtime about the chunk base path
-declare var TURBOPACK_WORKER_LOCATION: string
 // Used in WebWorkers to tell the runtime about the chunk suffix
 declare var TURBOPACK_CHUNK_SUFFIX: string
-// Used in WebWorkers to tell the runtime about the current chunk url since it can't be detected via document.currentScript
-// Note it's stored in reversed order to use push and pop
+// Used in WebWorkers to tell the runtime about the current chunk url since it
+// can't be detected via `document.currentScript`. Note it's stored in reversed
+// order to use `push` and `pop`
 declare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined
 
 // Injected by rust code
@@ -315,21 +314,36 @@ function resolveAbsolutePath(modulePath?: string): string {
 browserContextPrototype.P = resolveAbsolutePath
 
 /**
- * Returns a blob URL for the worker.
- * @param chunks list of chunks to load
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
  */
-function getWorkerBlobURL(chunks: ChunkPath[]): string {
-  // It is important to reverse the array so when bootstrapping we can infer what chunk is being
-  // evaluated by poping urls off of this array.  See `getPathFromScript`
-  let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};
-self.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};
-self.NEXT_DEPLOYMENT_ID = ${JSON.stringify((globalThis as any).NEXT_DEPLOYMENT_ID)};
-self.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};
-importScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`
-  let blob = new Blob([bootstrap], { type: 'text/javascript' })
-  return URL.createObjectURL(blob)
+function getWorkerURL(
+  entrypoint: ChunkPath,
+  moduleChunks: ChunkPath[],
+  shared: boolean
+): URL {
+  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)
+
+  const params = {
+    S: CHUNK_SUFFIX,
+    N: (globalThis as any).NEXT_DEPLOYMENT_ID,
+    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),
+  }
+
+  const paramsJson = JSON.stringify(params)
+  if (shared) {
+    url.searchParams.set('params', paramsJson)
+  } else {
+    url.hash = '#params=' + encodeURIComponent(paramsJson)
+  }
+  return url
 }
-browserContextPrototype.b = getWorkerBlobURL
+browserContextPrototype.b = getWorkerURL
 
 /**
  * Instantiates a runtime module.
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/worker-entrypoint.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/worker-entrypoint.ts
new file mode 100644
index 00000000000000..c7651f7f753e8c
--- /dev/null
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/worker-entrypoint.ts
@@ -0,0 +1,81 @@
+/**
+ * Worker entrypoint bootstrap.
+ */
+
+interface WorkerBootstrapConfig {
+  // TURBOPACK_CHUNK_SUFFIX
+  S?: string
+  // NEXT_DEPLOYMENT_ID
+  N?: string
+  // TURBOPACK_NEXT_CHUNK_URLS
+  NC?: string[]
+}
+
+;(() => {
+  function abort(message: string): never {
+    console.error(message)
+    throw new Error(message)
+  }
+
+  // Security: Ensure this code is running in a worker environment to prevent
+  // the worker entrypoint being used as an XSS gadget. If this is a worker, we
+  // know that the origin of the caller is the same as our origin.
+  if (
+    typeof (self as any)['WorkerGlobalScope'] === 'undefined' ||
+    !(self instanceof (self as any)['WorkerGlobalScope'])
+  ) {
+    abort('Worker entrypoint must be loaded in a worker context')
+  }
+
+  const url = new URL(location.href)
+
+  // Try querystring first (SharedWorker), then hash (regular Worker)
+  let paramsString = url.searchParams.get('params')
+  if (!paramsString && url.hash.startsWith('#params=')) {
+    paramsString = decodeURIComponent(url.hash.slice('#params='.length))
+  }
+
+  if (!paramsString) abort('Missing worker bootstrap config')
+
+  // Safety: this string requires that a script on the same origin has loaded
+  // this code as a module. We still don't fully trust it, so we'll validate the
+  // types and ensure that the next chunk URLs are same-origin.
+  const config: WorkerBootstrapConfig = JSON.parse(paramsString)
+
+  const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : ''
+  const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : ''
+  // In a normal browser context, the runtime can figure out which chunk is
+  // currently executing via `document.currentScript`. Workers don't have that
+  // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead
+  // (`reverse()`d below).
+  //
+  // Each chunk pops its URL off the front of the array when it runs, so we need
+  // to store them in reverse order to make sure the first chunk to execute sees
+  // its own URL at the front.
+  const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : []
+
+  Object.assign(self, {
+    TURBOPACK_CHUNK_SUFFIX,
+    TURBOPACK_NEXT_CHUNK_URLS,
+    NEXT_DEPLOYMENT_ID,
+  })
+
+  if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+    const scriptsToLoad: string[] = []
+    for (const chunk of TURBOPACK_NEXT_CHUNK_URLS) {
+      // Chunks are relative to the origin.
+      const chunkUrl = new URL(chunk, location.origin)
+      // Security: Only load scripts from the same origin. This prevents this
+      // worker entrypoint from being used as a gadget to load scripts from
+      // foreign origins if someone happens to find a separate XSS vector
+      // elsewhere on this origin.
+      if (chunkUrl.origin !== location.origin) {
+        abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`)
+      }
+      scriptsToLoad.push(chunkUrl.toString())
+    }
+
+    TURBOPACK_NEXT_CHUNK_URLS.reverse()
+    importScripts(...scriptsToLoad)
+  }
+})()
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts
index 32aa7a25d36b64..d56b876b42ffb7 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts
@@ -164,7 +164,7 @@ const chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()
         // ignore
       } else if (isJs(chunkUrl)) {
         self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)
-        importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl)
+        importScripts(chunkUrl)
       } else {
         throw new Error(
           `can't infer type of chunk from URL ${chunkUrl} in worker`
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.ts
index 29c77dde78e3fd..119b8a9ed92fbd 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.ts
@@ -178,11 +178,15 @@ function loadWebAssemblyModule(
 }
 contextPrototype.u = loadWebAssemblyModule
 
-function getWorkerBlobURL(_chunks: ChunkPath[]): string {
-  throw new Error('Worker blobs are not implemented yet for Node.js')
+function getWorkerURL(
+  _entrypoint: ChunkPath,
+  _moduleChunks: ChunkPath[],
+  _shared: boolean
+): URL {
+  throw new Error('Worker urls are not implemented yet for Node.js')
 }
 
-nodeContextPrototype.b = getWorkerBlobURL
+nodeContextPrototype.b = getWorkerURL
 
 function instantiateModule(
   id: ModuleId,
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime-types.d.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime-types.d.ts
index 02a2d7c12bf7c9..375136faf31d8f 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime-types.d.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime-types.d.ts
@@ -86,7 +86,11 @@ type AsyncModule = (
 ) => void
 
 type ResolveAbsolutePath = (modulePath?: string) => string
-type GetWorkerBlobURL = (chunks: ChunkPath[]) => string
+type GetWorkerURL = (
+  entrypoint: ChunkPath,
+  moduleChunks: ChunkPath[],
+  shared: boolean
+) => URL
 
 type ExternalRequire = (
   id: DependencySpecifier,
@@ -133,7 +137,7 @@ interface TurbopackBaseContext<M> {
   u: LoadWebAssemblyModule
   P: ResolveAbsolutePath
   U: RelativeURL
-  b: GetWorkerBlobURL
+  b: GetWorkerURL
   x: ExternalRequire
   y: ExternalImport
   z: CommonJsRequire
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs b/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs
index 2fee2a1b417ea4..4f5d357b16f418 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs
+++ b/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs
@@ -205,3 +205,15 @@ pub async fn get_browser_runtime_code(
 
     Ok(Code::cell(code.build()))
 }
+
+/// Returns the code for the ECMAScript worker entrypoint bootstrap.
+pub fn get_worker_runtime_code(
+    asset_context: Vc<Box<dyn AssetContext>>,
+    generate_source_map: bool,
+) -> Result<Vc<Code>> {
+    Ok(embed_static_code(
+        asset_context,
+        rcstr!("browser/runtime/base/worker-entrypoint.ts"),
+        generate_source_map,
+    ))
+}
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/src/lib.rs b/turbopack/crates/turbopack-ecmascript-runtime/src/lib.rs
index a982a1e08e277b..1611111edf0717 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/src/lib.rs
+++ b/turbopack/crates/turbopack-ecmascript-runtime/src/lib.rs
@@ -10,7 +10,7 @@ pub(crate) mod embed_js;
 pub(crate) mod nodejs_runtime;
 pub(crate) mod runtime_type;
 
-pub use browser_runtime::get_browser_runtime_code;
+pub use browser_runtime::{get_browser_runtime_code, get_worker_runtime_code};
 pub use chunk_suffix::ChunkSuffix;
 #[cfg(feature = "test")]
 pub use dummy_runtime::get_dummy_runtime_code;
diff --git a/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs b/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs
index 09440c7818f990..1e9ebfcbbc734c 100644
--- a/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs
@@ -1862,6 +1862,10 @@ impl JsValue {
                       "Worker".to_string(),
                       "The standard Worker constructor: https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker"
                     ),
+                    WellKnownFunctionKind::SharedWorkerConstructor => (
+                      "SharedWorker".to_string(),
+                      "The standard SharedWorker constructor: https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker/SharedWorker"
+                    ),
                     WellKnownFunctionKind::URLConstructor => (
                       "URL".to_string(),
                       "The standard URL constructor: https://developer.mozilla.org/en-US/docs/Web/API/URL/URL"
@@ -3527,6 +3531,7 @@ pub enum WellKnownFunctionKind {
     NodeResolveFrom,
     NodeProtobufLoad,
     WorkerConstructor,
+    SharedWorkerConstructor,
     // The worker_threads Worker class
     NodeWorkerConstructor,
     URLConstructor,
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/mod.rs b/turbopack/crates/turbopack-ecmascript/src/references/mod.rs
index bb685bb70fb6e6..bc77b379f9bd19 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/mod.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/mod.rs
@@ -78,7 +78,7 @@ use turbopack_core::{
     issue::{IssueExt, IssueSeverity, IssueSource, StyledString, analyze::AnalyzeIssue},
     module::{Module, ModuleSideEffects},
     reference::{ModuleReference, ModuleReferences},
-    reference_type::{CommonJsReferenceSubType, ReferenceType},
+    reference_type::{CommonJsReferenceSubType, ReferenceType, WorkerReferenceSubType},
     resolve::{
         FindContextFileResult, ImportUsage, ModulePart, find_context_file,
         origin::{PlainResolveOrigin, ResolveOrigin},
@@ -1915,15 +1915,25 @@ where
                 }
                 return Ok(());
             }
-            WellKnownFunctionKind::WorkerConstructor => {
+            WellKnownFunctionKind::WorkerConstructor
+            | WellKnownFunctionKind::SharedWorkerConstructor => {
                 let args = linked_args().await?;
                 if let Some(url @ JsValue::Url(_, JsValueUrlKind::Relative)) = args.first() {
+                    let (name, worker_type) = match func {
+                        WellKnownFunctionKind::WorkerConstructor => {
+                            ("Worker", WorkerReferenceSubType::WebWorker)
+                        }
+                        WellKnownFunctionKind::SharedWorkerConstructor => {
+                            ("SharedWorker", WorkerReferenceSubType::SharedWorker)
+                        }
+                        _ => unreachable!(),
+                    };
                     let pat = js_value_to_pattern(url);
                     if !pat.has_constant_parts() {
                         let (args, hints) = explain_args(args);
                         handler.span_warn_with_code(
                             span,
-                            &format!("new Worker({args}) is very dynamic{hints}",),
+                            &format!("new {name}({args}) is very dynamic{hints}",),
                             DiagnosticId::Lint(
                                 errors::failed_to_analyze::ecmascript::NEW_WORKER.to_string(),
                             ),
@@ -1940,6 +1950,7 @@ where
                                 Request::parse(pat).to_resolved().await?,
                                 issue_source(source, span),
                                 in_try,
+                                worker_type,
                             ),
                             ast_path.to_vec().into(),
                         );
@@ -3339,6 +3350,12 @@ async fn value_visitor_inner(
                 true,
                 "ignored Worker constructor",
             ),
+            "SharedWorker" => JsValue::unknown_if(
+                ignore,
+                JsValue::WellKnownFunction(WellKnownFunctionKind::SharedWorkerConstructor),
+                true,
+                "ignored SharedWorker constructor",
+            ),
             "define" => JsValue::WellKnownFunction(WellKnownFunctionKind::Define),
             "URL" => JsValue::WellKnownFunction(WellKnownFunctionKind::URLConstructor),
             "process" => JsValue::WellKnownObject(WellKnownObjectKind::NodeProcessModule),
@@ -4121,8 +4138,8 @@ fn is_invoking_node_process_eval(args: &[JsValue]) -> bool {
     if let JsValue::Member(_, obj, constant) = &args[0] {
         // Is the first argument to spawn `process.argv[]`?
         if let (
-            box JsValue::WellKnownObject(WellKnownObjectKind::NodeProcessArgv),
-            box JsValue::Constant(JsConstantValue::Num(ConstantNumber(num))),
+            &box JsValue::WellKnownObject(WellKnownObjectKind::NodeProcessArgv),
+            &box JsValue::Constant(JsConstantValue::Num(ConstantNumber(num))),
         ) = (obj, constant)
         {
             // Is it specifically `process.argv[0]`?
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/worker.rs b/turbopack/crates/turbopack-ecmascript/src/references/worker.rs
index 71fc372854c253..4765df238ccbaa 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/worker.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/worker.rs
@@ -34,6 +34,7 @@ pub struct WorkerAssetReference {
     pub request: ResolvedVc<Request>,
     pub issue_source: IssueSource,
     pub in_try: bool,
+    pub worker_type: WorkerReferenceSubType,
 }
 
 impl WorkerAssetReference {
@@ -42,25 +43,24 @@ impl WorkerAssetReference {
         request: ResolvedVc<Request>,
         issue_source: IssueSource,
         in_try: bool,
+        worker_type: WorkerReferenceSubType,
     ) -> Self {
         WorkerAssetReference {
             origin,
             request,
             issue_source,
             in_try,
+            worker_type,
         }
     }
 }
 
 impl WorkerAssetReference {
-    async fn worker_loader_module(
-        self: &WorkerAssetReference,
-    ) -> Result<Option<Vc<WorkerLoaderModule>>> {
+    async fn worker_loader_module(&self) -> Result<Option<Vc<WorkerLoaderModule>>> {
         let module = url_resolve(
             *self.origin,
             *self.request,
-            // TODO support more worker types
-            ReferenceType::Worker(WorkerReferenceSubType::WebWorker),
+            ReferenceType::Worker(self.worker_type),
             Some(self.issue_source),
             self.in_try,
         );
@@ -81,7 +81,11 @@ impl WorkerAssetReference {
             return Ok(None);
         };
 
-        Ok(Some(WorkerLoaderModule::new(*chunkable)))
+        Ok(Some(WorkerLoaderModule::new(
+            *chunkable,
+            self.worker_type,
+            *self.origin.asset_context().to_resolved().await?,
+        )))
     }
 }
 
diff --git a/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs b/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs
index ecb1fdf1831e3c..4c7f508d596e20 100644
--- a/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs
@@ -82,7 +82,7 @@ pub const TURBOPACK_DYNAMIC: &TurbopackRuntimeFunctionShortcut = make_shortcut!(
 pub const TURBOPACK_RESOLVE_ABSOLUTE_PATH: &TurbopackRuntimeFunctionShortcut = make_shortcut!("P");
 pub const TURBOPACK_RELATIVE_URL: &TurbopackRuntimeFunctionShortcut = make_shortcut!("U");
 pub const TURBOPACK_RESOLVE_MODULE_ID_PATH: &TurbopackRuntimeFunctionShortcut = make_shortcut!("R");
-pub const TURBOPACK_WORKER_BLOB_URL: &TurbopackRuntimeFunctionShortcut = make_shortcut!("b");
+pub const TURBOPACK_WORKER_URL: &TurbopackRuntimeFunctionShortcut = make_shortcut!("b");
 pub const TURBOPACK_ASYNC_MODULE: &TurbopackRuntimeFunctionShortcut = make_shortcut!("a");
 pub const TURBOPACK_EXTERNAL_REQUIRE: &TurbopackRuntimeFunctionShortcut = make_shortcut!("x");
 pub const TURBOPACK_EXTERNAL_IMPORT: &TurbopackRuntimeFunctionShortcut = make_shortcut!("y");
@@ -115,7 +115,7 @@ pub const TURBOPACK_RUNTIME_FUNCTION_SHORTCUTS: [(&str, &TurbopackRuntimeFunctio
         "__turbopack_resolve_module_id_path__",
         TURBOPACK_RESOLVE_MODULE_ID_PATH,
     ),
-    ("__turbopack_worker_blob_url__", TURBOPACK_WORKER_BLOB_URL),
+    ("__turbopack_worker_url__", TURBOPACK_WORKER_URL),
     ("__turbopack_external_require__", TURBOPACK_EXTERNAL_REQUIRE),
     ("__turbopack_external_import__", TURBOPACK_EXTERNAL_IMPORT),
     ("__turbopack_refresh__", TURBOPACK_REFRESH),
diff --git a/turbopack/crates/turbopack-ecmascript/src/worker_chunk/chunk_item.rs b/turbopack/crates/turbopack-ecmascript/src/worker_chunk/chunk_item.rs
index 87864d547e1f0a..7a798c5dd5ad2e 100644
--- a/turbopack/crates/turbopack-ecmascript/src/worker_chunk/chunk_item.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/worker_chunk/chunk_item.rs
@@ -7,10 +7,12 @@ use turbopack_core::{
         ChunkData, ChunkItem, ChunkType, ChunkingContext, ChunkingContextExt, ChunksData,
         availability_info::AvailabilityInfo,
     },
+    context::AssetContext,
     ident::AssetIdent,
     module::Module,
     module_graph::{ModuleGraph, chunk_group_info::ChunkGroup},
-    output::{OutputAssetsReference, OutputAssetsWithReferenced},
+    output::{OutputAsset, OutputAssetsReference, OutputAssetsWithReferenced},
+    reference_type::WorkerReferenceSubType,
 };
 
 use super::module::WorkerLoaderModule;
@@ -19,7 +21,7 @@ use crate::{
         EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkType,
         data::EcmascriptChunkData,
     },
-    runtime_functions::{TURBOPACK_EXPORT_VALUE, TURBOPACK_WORKER_BLOB_URL},
+    runtime_functions::{TURBOPACK_EXPORT_VALUE, TURBOPACK_WORKER_URL},
     utils::StringifyJs,
 };
 
@@ -28,6 +30,8 @@ pub struct WorkerLoaderChunkItem {
     pub module: ResolvedVc<WorkerLoaderModule>,
     pub module_graph: ResolvedVc<ModuleGraph>,
     pub chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
+    pub asset_context: ResolvedVc<Box<dyn AssetContext>>,
+    pub worker_type: WorkerReferenceSubType,
 }
 
 #[turbo_tasks::value_impl]
@@ -35,7 +39,6 @@ impl WorkerLoaderChunkItem {
     #[turbo_tasks::function]
     async fn chunk_group(&self) -> Result<Vc<OutputAssetsWithReferenced>> {
         let module = self.module.await?;
-
         Ok(self.chunking_context.evaluated_chunk_group_assets(
             module.inner.ident().with_modifier(rcstr!("worker")),
             ChunkGroup::Isolated(ResolvedVc::upcast(module.inner)),
@@ -58,6 +61,24 @@ impl WorkerLoaderChunkItem {
 impl EcmascriptChunkItem for WorkerLoaderChunkItem {
     #[turbo_tasks::function]
     async fn content(self: Vc<Self>) -> Result<Vc<EcmascriptChunkItemContent>> {
+        let this = self.await?;
+
+        // Get the worker entrypoint for this chunking context
+        let asset_context = *this.asset_context;
+        let entrypoint_full_path = this
+            .chunking_context
+            .worker_entrypoint(asset_context)
+            .path()
+            .await?;
+
+        // Get the entrypoint path relative to output root
+        let output_root = this.chunking_context.output_root().owned().await?;
+        let entrypoint_path = output_root
+            .get_path_to(&entrypoint_full_path)
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| entrypoint_full_path.path.to_string());
+
+        // Get the chunk data for the worker module
         let chunks_data = self.chunks_data().await?;
         let chunks_data = chunks_data.iter().try_join().await?;
         let chunks_data: Vec<_> = chunks_data
@@ -65,11 +86,17 @@ impl EcmascriptChunkItem for WorkerLoaderChunkItem {
             .map(|chunk_data| EcmascriptChunkData::new(chunk_data))
             .collect();
 
+        // Determine if this is a SharedWorker
+        let is_shared = matches!(this.worker_type, WorkerReferenceSubType::SharedWorker);
+
+        // Generate code that creates a worker URL with the entrypoint and chunk paths
         let code = formatdoc! {
             r#"
-                {TURBOPACK_EXPORT_VALUE}({TURBOPACK_WORKER_BLOB_URL}({chunks:#}));
+                {TURBOPACK_EXPORT_VALUE}({TURBOPACK_WORKER_URL}({entrypoint}, {chunks}, {shared}));
             "#,
+            entrypoint = StringifyJs(&entrypoint_path),
             chunks = StringifyJs(&chunks_data),
+            shared = is_shared,
         };
 
         Ok(EcmascriptChunkItemContent {
@@ -83,8 +110,12 @@ impl EcmascriptChunkItem for WorkerLoaderChunkItem {
 #[turbo_tasks::value_impl]
 impl OutputAssetsReference for WorkerLoaderChunkItem {
     #[turbo_tasks::function]
-    fn references(self: Vc<Self>) -> Vc<OutputAssetsWithReferenced> {
-        self.chunk_group()
+    async fn references(self: Vc<Self>) -> Result<Vc<OutputAssetsWithReferenced>> {
+        let this = self.await?;
+        let asset_context = *this.asset_context;
+        Ok(self
+            .chunk_group()
+            .concatenate_asset(this.chunking_context.worker_entrypoint(asset_context)))
     }
 }
 
diff --git a/turbopack/crates/turbopack-ecmascript/src/worker_chunk/module.rs b/turbopack/crates/turbopack-ecmascript/src/worker_chunk/module.rs
index 825a29bf2551fe..e2dc1742dbb399 100644
--- a/turbopack/crates/turbopack-ecmascript/src/worker_chunk/module.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/worker_chunk/module.rs
@@ -7,10 +7,12 @@ use turbopack_core::{
         ChunkGroupType, ChunkableModule, ChunkableModuleReference, ChunkingContext, ChunkingType,
         ChunkingTypeOption,
     },
+    context::AssetContext,
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
     reference::{ModuleReference, ModuleReferences},
+    reference_type::WorkerReferenceSubType,
     resolve::ModuleResolveResult,
 };
 
@@ -21,13 +23,23 @@ use super::chunk_item::WorkerLoaderChunkItem;
 #[turbo_tasks::value]
 pub struct WorkerLoaderModule {
     pub inner: ResolvedVc<Box<dyn ChunkableModule>>,
+    pub worker_type: WorkerReferenceSubType,
+    pub asset_context: ResolvedVc<Box<dyn AssetContext>>,
 }
 
 #[turbo_tasks::value_impl]
 impl WorkerLoaderModule {
     #[turbo_tasks::function]
-    pub fn new(module: ResolvedVc<Box<dyn ChunkableModule>>) -> Vc<Self> {
-        Self::cell(WorkerLoaderModule { inner: module })
+    pub fn new(
+        module: ResolvedVc<Box<dyn ChunkableModule>>,
+        worker_type: WorkerReferenceSubType,
+        asset_context: ResolvedVc<Box<dyn AssetContext>>,
+    ) -> Vc<Self> {
+        Self::cell(WorkerLoaderModule {
+            inner: module,
+            worker_type,
+            asset_context,
+        })
     }
 
     #[turbo_tasks::function]
@@ -74,19 +86,22 @@ impl Asset for WorkerLoaderModule {
 #[turbo_tasks::value_impl]
 impl ChunkableModule for WorkerLoaderModule {
     #[turbo_tasks::function]
-    fn as_chunk_item(
+    async fn as_chunk_item(
         self: ResolvedVc<Self>,
         module_graph: ResolvedVc<ModuleGraph>,
         chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        Vc::upcast(
+    ) -> Result<Vc<Box<dyn turbopack_core::chunk::ChunkItem>>> {
+        let this = self.await?;
+        Ok(Vc::upcast(
             WorkerLoaderChunkItem {
                 module: self,
                 module_graph,
                 chunking_context,
+                worker_type: this.worker_type,
+                asset_context: this.asset_context,
             }
             .cell(),
-        )
+        ))
     }
 }
 
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot.rs b/turbopack/crates/turbopack-tests/tests/snapshot.rs
index 8e86247f7435ff..f2b022d105e9da 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot.rs
+++ b/turbopack/crates/turbopack-tests/tests/snapshot.rs
@@ -48,7 +48,7 @@ use turbopack_core::{
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
     },
     output::{OutputAsset, OutputAssets, OutputAssetsReference, OutputAssetsWithReferenced},
-    reference_type::{EntryReferenceSubType, ReferenceType},
+    reference_type::{EntryReferenceSubType, ReferenceType, UrlReferenceSubType},
     source::Source,
 };
 use turbopack_ecmascript::{
@@ -325,11 +325,16 @@ async fn run_test_operation(resource: RcStr) -> Result<Vc<FileSystemPath>> {
         .cell()
         .await?;
 
-    let conditions = RuleCondition::any(vec![
-        RuleCondition::ResourcePathEndsWith(".js".into()),
-        RuleCondition::ResourcePathEndsWith(".jsx".into()),
-        RuleCondition::ResourcePathEndsWith(".ts".into()),
-        RuleCondition::ResourcePathEndsWith(".tsx".into()),
+    let conditions = RuleCondition::All(vec![
+        RuleCondition::not(RuleCondition::ReferenceType(ReferenceType::Url(
+            UrlReferenceSubType::Undefined,
+        ))),
+        RuleCondition::any(vec![
+            RuleCondition::ResourcePathEndsWith(".js".into()),
+            RuleCondition::ResourcePathEndsWith(".jsx".into()),
+            RuleCondition::ResourcePathEndsWith(".ts".into()),
+            RuleCondition::ResourcePathEndsWith(".tsx".into()),
+        ]),
     ]);
 
     let module_rules = ModuleRule::new(
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/aaf3a_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/aaf3a_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js.map
index 596ad278750a22..5d8079009569e2 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/aaf3a_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/aaf3a_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js.map
@@ -1,11 +1,11 @@
 {
   "version": 3,
   "sources": [],
-  "debugId": "3834607a-5e38-b3f2-d7f2-094bfde98e30",
+  "debugId": "2edabdcd-1a50-190d-01a5-132504146b5c",
   "sections": [
     {"offset": {"line": 14, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","err","asyncModule","body","hasAwait","depQueues","Set","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 515, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk base path\ndeclare var TURBOPACK_WORKER_LOCATION: string\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it can't be detected via document.currentScript\n// Note it's stored in reversed order to use push and pop\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a blob URL for the worker.\n * @param chunks list of chunks to load\n */\nfunction getWorkerBlobURL(chunks: ChunkPath[]): string {\n  // It is important to reverse the array so when bootstrapping we can infer what chunk is being\n  // evaluated by poping urls off of this array.  See `getPathFromScript`\n  let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};\nself.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};\nself.NEXT_DEPLOYMENT_ID = ${JSON.stringify((globalThis as any).NEXT_DEPLOYMENT_ID)};\nself.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};\nimportScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`\n  let blob = new Blob([bootstrap], { type: 'text/javascript' })\n  return URL.createObjectURL(blob)\n}\nbrowserContextPrototype.b = getWorkerBlobURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerBlobURL","chunks","bootstrap","JSON","stringify","location","origin","CHUNK_SUFFIX","globalThis","NEXT_DEPLOYMENT_ID","reverse","blob","Blob","type","URL","createObjectURL","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","encodeURIComponent","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"AAAA;;;;;;CAMC,GAED,oDAAoD,GAEpD,6CAA6C;AAC7C,yDAAyD;AAEzD,mEAAmE;AAgBnE,MAAMA,0BACJC,QAAQC,SAAS;AAyBnB,IAAA,AAAKC,oCAAAA;IACH;;;;GAIC;IAED;;;GAGC;IAED;;;;GAIC;WAhBEA;EAAAA;AAgDL,MAAMC,kBAAmC,IAAIC;AAC7CC,iBAAiBC,CAAC,GAAGH;AAErB,MAAMI,mBAAuD,IAAIH;AAEjE,MAAMI,wBAA6D,IAAIJ;AAEvE,SAASK,2BACPC,QAAkB,EAClBC,UAAsB,EACtBC,UAAsB;IAEtB,IAAIC;IACJ,OAAQF;QACN;YACEE,sBAAsB,CAAC,4BAA4B,EAAED,YAAY;YACjE;QACF;YACEC,sBAAsB,CAAC,oCAAoC,EAAED,YAAY;YACzE;QACF;YACEC,sBAAsB;YACtB;QACF;YACEC,UACEH,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;IAE1D;IACA,OAAO,CAAC,OAAO,EAAED,SAAS,kBAAkB,EAAEG,oBAAoB,0CAA0C,CAAC;AAC/G;AAEA,SAASE,UAEPC,SAAoB;IAEpB,OAAOC,qBAAqC,IAAI,CAACC,CAAC,CAACC,EAAE,EAAEH;AACzD;AACAjB,wBAAwBqB,CAAC,GAAGL;AAE5B,SAASM,iBAAiBC,SAAoB,EAAEN,SAAoB;IAClE,OAAOC,qBAAsCK,WAAWN;AAC1D;AAEA,eAAeC,kBACbN,UAAsB,EACtBC,UAAsB,EACtBI,SAAoB;IAEpB,IAAI,OAAOA,cAAc,UAAU;QACjC,OAAOO,cAAcZ,YAAYC,YAAYI;IAC/C;IAEA,MAAMQ,eAAeR,UAAUS,QAAQ,IAAI,EAAE;IAC7C,MAAMC,kBAAkBF,aAAaG,GAAG,CAAC,CAACF;QACxC,IAAItB,gBAAgByB,GAAG,CAACH,WAAW,OAAO;QAC1C,OAAOlB,iBAAiBsB,GAAG,CAACJ;IAC9B;IACA,IAAIC,gBAAgBI,MAAM,GAAG,KAAKJ,gBAAgBK,KAAK,CAAC,CAACC,IAAMA,IAAI;QACjE,uFAAuF;QACvF,MAAMC,QAAQC,GAAG,CAACR;QAClB;IACF;IAEA,MAAMS,2BAA2BnB,UAAUoB,YAAY,IAAI,EAAE;IAC7D,MAAMC,uBAAuBF,yBAC1BR,GAAG,CAAC,CAACF;QACJ,yCAAyC;QACzC,8CAA8C;QAC9C,OAAOjB,sBAAsBqB,GAAG,CAACJ;IACnC,GACCa,MAAM,CAAC,CAACN,IAAMA;IAEjB,IAAIO;IACJ,IAAIF,qBAAqBP,MAAM,GAAG,GAAG;QACnC,oDAAoD;QAEpD,IAAIO,qBAAqBP,MAAM,KAAKK,yBAAyBL,MAAM,EAAE;YACnE,+FAA+F;YAC/F,MAAMG,QAAQC,GAAG,CAACG;YAClB;QACF;QAEA,MAAMG,qBAAqC,IAAIC;QAC/C,KAAK,MAAMC,eAAeP,yBAA0B;YAClD,IAAI,CAAC3B,sBAAsBoB,GAAG,CAACc,cAAc;gBAC3CF,mBAAmBG,GAAG,CAACD;YACzB;QACF;QAEA,KAAK,MAAME,qBAAqBJ,mBAAoB;YAClD,MAAMD,UAAUhB,cAAcZ,YAAYC,YAAYgC;YAEtDpC,sBAAsBqC,GAAG,CAACD,mBAAmBL;YAE7CF,qBAAqBS,IAAI,CAACP;QAC5B;QAEAA,UAAUN,QAAQC,GAAG,CAACG;IACxB,OAAO;QACLE,UAAUhB,cAAcZ,YAAYC,YAAYI,UAAU+B,IAAI;QAE9D,wFAAwF;QACxF,KAAK,MAAMC,uBAAuBb,yBAA0B;YAC1D,IAAI,CAAC3B,sBAAsBoB,GAAG,CAACoB,sBAAsB;gBACnDxC,sBAAsBqC,GAAG,CAACG,qBAAqBT;YACjD;QACF;IACF;IAEA,KAAK,MAAMd,YAAYD,aAAc;QACnC,IAAI,CAACjB,iBAAiBqB,GAAG,CAACH,WAAW;YACnC,qIAAqI;YACrI,yGAAyG;YACzGlB,iBAAiBsC,GAAG,CAACpB,UAAUc;QACjC;IACF;IAEA,MAAMA;AACR;AAEA,MAAMU,cAAchB,QAAQiB,OAAO,CAACC;AACpC,MAAMC,gCAAgC,IAAIC;AAI1C,wFAAwF;AACxF,SAASC,eAEPC,QAAkB;IAElB,OAAOC,0BAA0C,IAAI,CAACtC,CAAC,CAACC,EAAE,EAAEoC;AAC9D;AACAxD,wBAAwB0D,CAAC,GAAGH;AAE5B,wFAAwF;AACxF,SAASE,uBACP7C,UAAsB,EACtBC,UAAsB,EACtB2C,QAAkB;IAElB,MAAMG,WAAWC,QAAQC,eAAe,CAACjD,YAAY4C;IACrD,IAAIM,QAAQT,8BAA8BvB,GAAG,CAAC6B;IAC9C,IAAIG,UAAUV,WAAW;QACvB,MAAMD,UAAUE,8BAA8BP,GAAG,CAACiB,IAAI,CACpDV,+BACAM,UACAT;QAEFY,QAAQH,SAASK,IAAI,CAACb,SAASc,KAAK,CAAC,CAACC;YACpC,IAAIC;YACJ,OAAQvD;gBACN;oBACEuD,aAAa,CAAC,iCAAiC,EAAEtD,YAAY;oBAC7D;gBACF;oBACEsD,aAAa,CAAC,YAAY,EAAEtD,YAAY;oBACxC;gBACF;oBACEsD,aAAa;oBACb;gBACF;oBACEpD,UACEH,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;YAE1D;YACA,IAAIwD,QAAQ,IAAIC,MACd,CAAC,qBAAqB,EAAEb,SAAS,CAAC,EAAEW,aAClCD,QAAQ,CAAC,EAAE,EAAEA,OAAO,GAAG,IACvB,EACFA,QAAQ;gBAAEA;YAAM,IAAId;YAEtBgB,MAAME,IAAI,GAAG;YACb,MAAMF;QACR;QACAf,8BAA8BP,GAAG,CAACa,UAAUG;IAC9C;IAEA,OAAOA;AACT;AAEA,wFAAwF;AACxF,SAAStC,cACPZ,UAAsB,EACtBC,UAAsB,EACtBU,SAAoB;IAEpB,MAAMgD,MAAMC,oBAAoBjD;IAChC,OAAOkC,uBAAuB7C,YAAYC,YAAY0D;AACxD;AAEA;;CAEC,GACD,SAASE,sBAEP9D,QAAgB;IAEhB,MAAM+D,WAAW,IAAI,CAACC,CAAC,CAAChE;IACxB,OAAO+D,UAAUE,WAAWF;AAC9B;AACA1E,wBAAwB6E,CAAC,GAAGJ;AAE5B;;;CAGC,GACD,SAASK,oBAAoBC,UAAmB;IAC9C,OAAO,CAAC,MAAM,EAAEA,cAAc,IAAI;AACpC;AACA/E,wBAAwBgF,CAAC,GAAGF;AAE5B;;;CAGC,GACD,SAASG,iBAAiBC,MAAmB;IAC3C,8FAA8F;IAC9F,uEAAuE;IACvE,IAAIC,YAAY,CAAC,iCAAiC,EAAEC,KAAKC,SAAS,CAACC,SAASC,MAAM,EAAE;8BACxD,EAAEH,KAAKC,SAAS,CAACG,cAAc;0BACnC,EAAEJ,KAAKC,SAAS,CAAC,AAACI,WAAmBC,kBAAkB,EAAE;iCAClD,EAAEN,KAAKC,SAAS,CAACH,OAAOS,OAAO,GAAG/D,GAAG,CAAC4C,sBAAsB,MAAM,GAAG;wGACE,CAAC;IACvG,IAAIoB,OAAO,IAAIC,KAAK;QAACV;KAAU,EAAE;QAAEW,MAAM;IAAkB;IAC3D,OAAOC,IAAIC,eAAe,CAACJ;AAC7B;AACA5F,wBAAwBiG,CAAC,GAAGhB;AAE5B;;CAEC,GACD,SAASiB,yBACPvF,QAAkB,EAClBY,SAAoB;IAEpB,OAAO4E,kBAAkBxF,aAA8BY;AACzD;AACA;;CAEC,GACD,SAASiD,oBAAoBjD,SAAoC;IAC/D,OAAO,GAAG6E,kBAAkB7E,UACzB8E,KAAK,CAAC,KACNzE,GAAG,CAAC,CAACK,IAAMqE,mBAAmBrE,IAC9BsE,IAAI,CAAC,OAAOf,cAAc;AAC/B;AASA,SAASgB,kBACPC,WAAsE;IAEtE,IAAI,OAAOA,gBAAgB,UAAU;QACnC,OAAOA;IACT;IACA,MAAMjD,WACJ,OAAOkD,8BAA8B,cACjCA,0BAA0BC,GAAG,KAC7BF,YAAYG,YAAY,CAAC;IAC/B,MAAMC,MAAMC,mBAAmBtD,SAASuD,OAAO,CAAC,WAAW;IAC3D,MAAM/D,OAAO6D,IAAIG,UAAU,CAACZ,mBACxBS,IAAII,KAAK,CAACb,gBAAgBrE,MAAM,IAChC8E;IACJ,OAAO7D;AACT;AAEA,MAAMkE,aAAa;AACnB;;CAEC,GACD,SAASC,KAAKC,cAAoC;IAChD,OAAOF,WAAWG,IAAI,CAACD;AACzB;AAEA,MAAME,cAAc;AACpB;;CAEC,GACD,SAASC,MAAM/D,QAAkB;IAC/B,OAAO8D,YAAYD,IAAI,CAAC7D;AAC1B;AAEA,SAASgE,gBAEPjG,SAAoB,EACpBkG,UAAoC,EACpCC,UAA+B;IAE/B,OAAO9D,QAAQ4D,eAAe,IAE5B,IAAI,CAACrG,CAAC,CAACC,EAAE,EACTG,WACAkG,YACAC;AAEJ;AACApH,iBAAiBqH,CAAC,GAAGH;AAErB,SAASI,sBAEPrG,SAAoB,EACpBkG,UAAoC;IAEpC,OAAO7D,QAAQgE,qBAAqB,IAElC,IAAI,CAACzG,CAAC,CAACC,EAAE,EACTG,WACAkG;AAEJ;AACAnH,iBAAiBuH,CAAC,GAAGD","ignoreList":[0]}},
-    {"offset": {"line": 743, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1597, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","TURBOPACK_WORKER_LOCATION","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1762, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 515, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"AAAA;;;;;;CAMC,GAED,oDAAoD,GAEpD,6CAA6C;AAC7C,yDAAyD;AAEzD,gEAAgE;AAehE,MAAMA,0BACJC,QAAQC,SAAS;AAyBnB,IAAA,AAAKC,oCAAAA;IACH;;;;GAIC;IAED;;;GAGC;IAED;;;;GAIC;WAhBEA;EAAAA;AAgDL,MAAMC,kBAAmC,IAAIC;AAC7CC,iBAAiBC,CAAC,GAAGH;AAErB,MAAMI,mBAAuD,IAAIH;AAEjE,MAAMI,wBAA6D,IAAIJ;AAEvE,SAASK,2BACPC,QAAkB,EAClBC,UAAsB,EACtBC,UAAsB;IAEtB,IAAIC;IACJ,OAAQF;QACN;YACEE,sBAAsB,CAAC,4BAA4B,EAAED,YAAY;YACjE;QACF;YACEC,sBAAsB,CAAC,oCAAoC,EAAED,YAAY;YACzE;QACF;YACEC,sBAAsB;YACtB;QACF;YACEC,UACEH,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;IAE1D;IACA,OAAO,CAAC,OAAO,EAAED,SAAS,kBAAkB,EAAEG,oBAAoB,0CAA0C,CAAC;AAC/G;AAEA,SAASE,UAEPC,SAAoB;IAEpB,OAAOC,qBAAqC,IAAI,CAACC,CAAC,CAACC,EAAE,EAAEH;AACzD;AACAjB,wBAAwBqB,CAAC,GAAGL;AAE5B,SAASM,iBAAiBC,SAAoB,EAAEN,SAAoB;IAClE,OAAOC,qBAAsCK,WAAWN;AAC1D;AAEA,eAAeC,kBACbN,UAAsB,EACtBC,UAAsB,EACtBI,SAAoB;IAEpB,IAAI,OAAOA,cAAc,UAAU;QACjC,OAAOO,cAAcZ,YAAYC,YAAYI;IAC/C;IAEA,MAAMQ,eAAeR,UAAUS,QAAQ,IAAI,EAAE;IAC7C,MAAMC,kBAAkBF,aAAaG,GAAG,CAAC,CAACF;QACxC,IAAItB,gBAAgByB,GAAG,CAACH,WAAW,OAAO;QAC1C,OAAOlB,iBAAiBsB,GAAG,CAACJ;IAC9B;IACA,IAAIC,gBAAgBI,MAAM,GAAG,KAAKJ,gBAAgBK,KAAK,CAAC,CAACC,IAAMA,IAAI;QACjE,uFAAuF;QACvF,MAAMC,QAAQC,GAAG,CAACR;QAClB;IACF;IAEA,MAAMS,2BAA2BnB,UAAUoB,YAAY,IAAI,EAAE;IAC7D,MAAMC,uBAAuBF,yBAC1BR,GAAG,CAAC,CAACF;QACJ,yCAAyC;QACzC,8CAA8C;QAC9C,OAAOjB,sBAAsBqB,GAAG,CAACJ;IACnC,GACCa,MAAM,CAAC,CAACN,IAAMA;IAEjB,IAAIO;IACJ,IAAIF,qBAAqBP,MAAM,GAAG,GAAG;QACnC,oDAAoD;QAEpD,IAAIO,qBAAqBP,MAAM,KAAKK,yBAAyBL,MAAM,EAAE;YACnE,+FAA+F;YAC/F,MAAMG,QAAQC,GAAG,CAACG;YAClB;QACF;QAEA,MAAMG,qBAAqC,IAAIC;QAC/C,KAAK,MAAMC,eAAeP,yBAA0B;YAClD,IAAI,CAAC3B,sBAAsBoB,GAAG,CAACc,cAAc;gBAC3CF,mBAAmBG,GAAG,CAACD;YACzB;QACF;QAEA,KAAK,MAAME,qBAAqBJ,mBAAoB;YAClD,MAAMD,UAAUhB,cAAcZ,YAAYC,YAAYgC;YAEtDpC,sBAAsBqC,GAAG,CAACD,mBAAmBL;YAE7CF,qBAAqBS,IAAI,CAACP;QAC5B;QAEAA,UAAUN,QAAQC,GAAG,CAACG;IACxB,OAAO;QACLE,UAAUhB,cAAcZ,YAAYC,YAAYI,UAAU+B,IAAI;QAE9D,wFAAwF;QACxF,KAAK,MAAMC,uBAAuBb,yBAA0B;YAC1D,IAAI,CAAC3B,sBAAsBoB,GAAG,CAACoB,sBAAsB;gBACnDxC,sBAAsBqC,GAAG,CAACG,qBAAqBT;YACjD;QACF;IACF;IAEA,KAAK,MAAMd,YAAYD,aAAc;QACnC,IAAI,CAACjB,iBAAiBqB,GAAG,CAACH,WAAW;YACnC,qIAAqI;YACrI,yGAAyG;YACzGlB,iBAAiBsC,GAAG,CAACpB,UAAUc;QACjC;IACF;IAEA,MAAMA;AACR;AAEA,MAAMU,cAAchB,QAAQiB,OAAO,CAACC;AACpC,MAAMC,gCAAgC,IAAIC;AAI1C,wFAAwF;AACxF,SAASC,eAEPC,QAAkB;IAElB,OAAOC,0BAA0C,IAAI,CAACtC,CAAC,CAACC,EAAE,EAAEoC;AAC9D;AACAxD,wBAAwB0D,CAAC,GAAGH;AAE5B,wFAAwF;AACxF,SAASE,uBACP7C,UAAsB,EACtBC,UAAsB,EACtB2C,QAAkB;IAElB,MAAMG,WAAWC,QAAQC,eAAe,CAACjD,YAAY4C;IACrD,IAAIM,QAAQT,8BAA8BvB,GAAG,CAAC6B;IAC9C,IAAIG,UAAUV,WAAW;QACvB,MAAMD,UAAUE,8BAA8BP,GAAG,CAACiB,IAAI,CACpDV,+BACAM,UACAT;QAEFY,QAAQH,SAASK,IAAI,CAACb,SAASc,KAAK,CAAC,CAACC;YACpC,IAAIC;YACJ,OAAQvD;gBACN;oBACEuD,aAAa,CAAC,iCAAiC,EAAEtD,YAAY;oBAC7D;gBACF;oBACEsD,aAAa,CAAC,YAAY,EAAEtD,YAAY;oBACxC;gBACF;oBACEsD,aAAa;oBACb;gBACF;oBACEpD,UACEH,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;YAE1D;YACA,IAAIwD,QAAQ,IAAIC,MACd,CAAC,qBAAqB,EAAEb,SAAS,CAAC,EAAEW,aAClCD,QAAQ,CAAC,EAAE,EAAEA,OAAO,GAAG,IACvB,EACFA,QAAQ;gBAAEA;YAAM,IAAId;YAEtBgB,MAAME,IAAI,GAAG;YACb,MAAMF;QACR;QACAf,8BAA8BP,GAAG,CAACa,UAAUG;IAC9C;IAEA,OAAOA;AACT;AAEA,wFAAwF;AACxF,SAAStC,cACPZ,UAAsB,EACtBC,UAAsB,EACtBU,SAAoB;IAEpB,MAAMgD,MAAMC,oBAAoBjD;IAChC,OAAOkC,uBAAuB7C,YAAYC,YAAY0D;AACxD;AAEA;;CAEC,GACD,SAASE,sBAEP9D,QAAgB;IAEhB,MAAM+D,WAAW,IAAI,CAACC,CAAC,CAAChE;IACxB,OAAO+D,UAAUE,WAAWF;AAC9B;AACA1E,wBAAwB6E,CAAC,GAAGJ;AAE5B;;;CAGC,GACD,SAASK,oBAAoBC,UAAmB;IAC9C,OAAO,CAAC,MAAM,EAAEA,cAAc,IAAI;AACpC;AACA/E,wBAAwBgF,CAAC,GAAGF;AAE5B;;;;;;;;CAQC,GACD,SAASG,aACPC,UAAqB,EACrB7C,YAAyB,EACzB8C,MAAe;IAEf,MAAMZ,MAAM,IAAIa,IAAIZ,oBAAoBU,aAAaG,SAASC,MAAM;IAEpE,MAAMC,SAAS;QACbC,GAAGC;QACHC,GAAG,AAACC,WAAmBC,kBAAkB;QACzCC,IAAIxD,aAAaT,GAAG,CAAC,CAACkE,QAAUtB,oBAAoBsB;IACtD;IAEA,MAAMC,aAAaC,KAAKC,SAAS,CAACV;IAClC,IAAIJ,QAAQ;QACVZ,IAAI2B,YAAY,CAACpD,GAAG,CAAC,UAAUiD;IACjC,OAAO;QACLxB,IAAI4B,IAAI,GAAG,aAAaC,mBAAmBL;IAC7C;IACA,OAAOxB;AACT;AACAvE,wBAAwBqG,CAAC,GAAGpB;AAE5B;;CAEC,GACD,SAASqB,yBACP3F,QAAkB,EAClBY,SAAoB;IAEpB,OAAOgF,kBAAkB5F,aAA8BY;AACzD;AACA;;CAEC,GACD,SAASiD,oBAAoBjD,SAAoC;IAC/D,OAAO,GAAGiF,kBAAkBjF,UACzBkF,KAAK,CAAC,KACN7E,GAAG,CAAC,CAACK,IAAMmE,mBAAmBnE,IAC9ByE,IAAI,CAAC,OAAOjB,cAAc;AAC/B;AASA,SAASkB,kBACPC,WAAsE;IAEtE,IAAI,OAAOA,gBAAgB,UAAU;QACnC,OAAOA;IACT;IACA,MAAMpD,WACJ,OAAOqD,8BAA8B,cACjCA,0BAA0BC,GAAG,KAC7BF,YAAYG,YAAY,CAAC;IAC/B,MAAMC,MAAMC,mBAAmBzD,SAAS0D,OAAO,CAAC,WAAW;IAC3D,MAAMlE,OAAOgE,IAAIG,UAAU,CAACX,mBACxBQ,IAAII,KAAK,CAACZ,gBAAgBzE,MAAM,IAChCiF;IACJ,OAAOhE;AACT;AAEA,MAAMqE,aAAa;AACnB;;CAEC,GACD,SAASC,KAAKC,cAAoC;IAChD,OAAOF,WAAWG,IAAI,CAACD;AACzB;AAEA,MAAME,cAAc;AACpB;;CAEC,GACD,SAASC,MAAMlE,QAAkB;IAC/B,OAAOiE,YAAYD,IAAI,CAAChE;AAC1B;AAEA,SAASmE,gBAEPpG,SAAoB,EACpBqG,UAAoC,EACpCC,UAA+B;IAE/B,OAAOjE,QAAQ+D,eAAe,IAE5B,IAAI,CAACxG,CAAC,CAACC,EAAE,EACTG,WACAqG,YACAC;AAEJ;AACAvH,iBAAiBwH,CAAC,GAAGH;AAErB,SAASI,sBAEPxG,SAAoB,EACpBqG,UAAoC;IAEpC,OAAOhE,QAAQmE,qBAAqB,IAElC,IAAI,CAAC5G,CAAC,CAACC,EAAE,EACTG,WACAqG;AAEJ;AACAtH,iBAAiB0H,CAAC,GAAGD","ignoreList":[0]}},
+    {"offset": {"line": 748, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1602, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1767, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/ba425_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/ba425_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js
index 1d71dcd4028dd3..b2849067dc4c66 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/ba425_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/output/ba425_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js
@@ -1,4 +1,4 @@
-;!function(){try { var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof global?global:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&((e._debugIds|| (e._debugIds={}))[n]="3834607a-5e38-b3f2-d7f2-094bfde98e30")}catch(e){}}();
+;!function(){try { var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof global?global:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&((e._debugIds|| (e._debugIds={}))[n]="2edabdcd-1a50-190d-01a5-132504146b5c")}catch(e){}}();
 (globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([
     "output/ba425_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js",
     {"otherChunks":["output/aaf3a_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0b8736b3.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/browser/input/index.js [test] (ecmascript)"]}
@@ -521,7 +521,7 @@ function applyModuleFactoryName(factory) {
  * shared runtime utils.
  */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
 /// <reference path="../../../shared/runtime-utils.ts" />
-// Used in WebWorkers to tell the runtime about the chunk base path
+// Used in WebWorkers to tell the runtime about the chunk suffix
 const browserContextPrototype = Context.prototype;
 var SourceType = /*#__PURE__*/ function(SourceType) {
     /**
@@ -684,24 +684,29 @@ browserContextPrototype.R = resolvePathFromModule;
 }
 browserContextPrototype.P = resolveAbsolutePath;
 /**
- * Returns a blob URL for the worker.
- * @param chunks list of chunks to load
- */ function getWorkerBlobURL(chunks) {
-    // It is important to reverse the array so when bootstrapping we can infer what chunk is being
-    // evaluated by poping urls off of this array.  See `getPathFromScript`
-    let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};
-self.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};
-self.NEXT_DEPLOYMENT_ID = ${JSON.stringify(globalThis.NEXT_DEPLOYMENT_ID)};
-self.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};
-importScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`;
-    let blob = new Blob([
-        bootstrap
-    ], {
-        type: 'text/javascript'
-    });
-    return URL.createObjectURL(blob);
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    const url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    const params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map((chunk)=>getChunkRelativeUrl(chunk))
+    };
+    const paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
 }
-browserContextPrototype.b = getWorkerBlobURL;
+browserContextPrototype.b = getWorkerURL;
 /**
  * Instantiates a runtime module.
  */ function instantiateRuntimeModule(moduleId, chunkPath) {
@@ -1699,7 +1704,7 @@ let BACKEND;
             // ignore
             } else if (isJs(chunkUrl)) {
                 self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
-                importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl);
+                importScripts(chunkUrl);
             } else {
                 throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
             }
@@ -1862,5 +1867,5 @@ chunkListsToRegister.forEach(registerChunkList);
 })();
 
 
-//# debugId=3834607a-5e38-b3f2-d7f2-094bfde98e30
+//# debugId=2edabdcd-1a50-190d-01a5-132504146b5c
 //# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_debug-ids_browser_input_index_0151fefb.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js
index 8c379dd9a48a59..e57476f4287657 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js
@@ -708,10 +708,10 @@ function loadWebAssemblyModule(chunkPath, _edgeModule) {
     return compileWebAssemblyFromPath(resolved);
 }
 contextPrototype.u = loadWebAssemblyModule;
-function getWorkerBlobURL(_chunks) {
-    throw new Error('Worker blobs are not implemented yet for Node.js');
+function getWorkerURL(_entrypoint, _moduleChunks, _shared) {
+    throw new Error('Worker urls are not implemented yet for Node.js');
 }
-nodeContextPrototype.b = getWorkerBlobURL;
+nodeContextPrototype.b = getWorkerURL;
 function instantiateModule(id, sourceType, sourceData) {
     const moduleFactory = moduleFactories.get(id);
     if (typeof moduleFactory !== 'function') {
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js.map
index 7c103f1960f712..437e87e489e4ff 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/debug-ids/node/output/[turbopack]_runtime.js.map
@@ -6,5 +6,5 @@
     {"offset": {"line": 504, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/base-externals-utils.ts"],"sourcesContent":["/// <reference path=\"../shared/runtime-utils.ts\" />\n\n/// A 'base' utilities to support runtime can have externals.\n/// Currently this is for node.js / edge runtime both.\n/// If a fn requires node.js specific behavior, it should be placed in `node-external-utils` instead.\n\nasync function externalImport(id: DependencySpecifier) {\n  let raw\n  try {\n    raw = await import(id)\n  } catch (err) {\n    // TODO(alexkirsz) This can happen when a client-side module tries to load\n    // an external module we don't provide a shim for (e.g. querystring, url).\n    // For now, we fail semi-silently, but in the future this should be a\n    // compilation error.\n    throw new Error(`Failed to load external module ${id}: ${err}`)\n  }\n\n  if (raw && raw.__esModule && raw.default && 'default' in raw.default) {\n    return interopEsm(raw.default, createNS(raw), true)\n  }\n\n  return raw\n}\ncontextPrototype.y = externalImport\n\nfunction externalRequire(\n  id: ModuleId,\n  thunk: () => any,\n  esm: boolean = false\n): Exports | EsmNamespaceObject {\n  let raw\n  try {\n    raw = thunk()\n  } catch (err) {\n    // TODO(alexkirsz) This can happen when a client-side module tries to load\n    // an external module we don't provide a shim for (e.g. querystring, url).\n    // For now, we fail semi-silently, but in the future this should be a\n    // compilation error.\n    throw new Error(`Failed to load external module ${id}: ${err}`)\n  }\n\n  if (!esm || raw.__esModule) {\n    return raw\n  }\n\n  return interopEsm(raw, createNS(raw), true)\n}\n\nexternalRequire.resolve = (\n  id: string,\n  options?: {\n    paths?: string[]\n  }\n) => {\n  return require.resolve(id, options)\n}\ncontextPrototype.x = externalRequire\n"],"names":["externalImport","id","raw","err","Error","__esModule","default","interopEsm","createNS","contextPrototype","y","externalRequire","thunk","esm","resolve","options","require","x"],"mappings":"AAAA,mDAAmD;AAEnD,6DAA6D;AAC7D,sDAAsD;AACtD,qGAAqG;AAErG,eAAeA,eAAeC,EAAuB;IACnD,IAAIC;IACJ,IAAI;QACFA,MAAM,MAAM,MAAM,CAACD;IACrB,EAAE,OAAOE,KAAK;QACZ,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,qBAAqB;QACrB,MAAM,IAAIC,MAAM,CAAC,+BAA+B,EAAEH,GAAG,EAAE,EAAEE,KAAK;IAChE;IAEA,IAAID,OAAOA,IAAIG,UAAU,IAAIH,IAAII,OAAO,IAAI,aAAaJ,IAAII,OAAO,EAAE;QACpE,OAAOC,WAAWL,IAAII,OAAO,EAAEE,SAASN,MAAM;IAChD;IAEA,OAAOA;AACT;AACAO,iBAAiBC,CAAC,GAAGV;AAErB,SAASW,gBACPV,EAAY,EACZW,KAAgB,EAChBC,MAAe,KAAK;IAEpB,IAAIX;IACJ,IAAI;QACFA,MAAMU;IACR,EAAE,OAAOT,KAAK;QACZ,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,qBAAqB;QACrB,MAAM,IAAIC,MAAM,CAAC,+BAA+B,EAAEH,GAAG,EAAE,EAAEE,KAAK;IAChE;IAEA,IAAI,CAACU,OAAOX,IAAIG,UAAU,EAAE;QAC1B,OAAOH;IACT;IAEA,OAAOK,WAAWL,KAAKM,SAASN,MAAM;AACxC;AAEAS,gBAAgBG,OAAO,GAAG,CACxBb,IACAc;IAIA,OAAOC,QAAQF,OAAO,CAACb,IAAIc;AAC7B;AACAN,iBAAiBQ,CAAC,GAAGN","ignoreList":[0]}},
     {"offset": {"line": 545, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/node-externals-utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\ndeclare var RUNTIME_PUBLIC_PATH: string\ndeclare var RELATIVE_ROOT_PATH: string\ndeclare var ASSET_PREFIX: string\n\nconst path = require('path')\n\nconst relativePathToRuntimeRoot = path.relative(RUNTIME_PUBLIC_PATH, '.')\n// Compute the relative path to the `distDir`.\nconst relativePathToDistRoot = path.join(\n  relativePathToRuntimeRoot,\n  RELATIVE_ROOT_PATH\n)\nconst RUNTIME_ROOT = path.resolve(__filename, relativePathToRuntimeRoot)\n// Compute the absolute path to the root, by stripping distDir from the absolute path to this file.\nconst ABSOLUTE_ROOT = path.resolve(__filename, relativePathToDistRoot)\n\n/**\n * Returns an absolute path to the given module path.\n * Module path should be relative, either path to a file or a directory.\n *\n * This fn allows to calculate an absolute path for some global static values, such as\n * `__dirname` or `import.meta.url` that Turbopack will not embeds in compile time.\n * See ImportMetaBinding::code_generation for the usage.\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  if (modulePath) {\n    return path.join(ABSOLUTE_ROOT, modulePath)\n  }\n  return ABSOLUTE_ROOT\n}\nContext.prototype.P = resolveAbsolutePath\n"],"names":["path","require","relativePathToRuntimeRoot","relative","RUNTIME_PUBLIC_PATH","relativePathToDistRoot","join","RELATIVE_ROOT_PATH","RUNTIME_ROOT","resolve","__filename","ABSOLUTE_ROOT","resolveAbsolutePath","modulePath","Context","prototype","P"],"mappings":"AAAA,oDAAoD,GAMpD,MAAMA,OAAOC,QAAQ;AAErB,MAAMC,4BAA4BF,KAAKG,QAAQ,CAACC,qBAAqB;AACrE,8CAA8C;AAC9C,MAAMC,yBAAyBL,KAAKM,IAAI,CACtCJ,2BACAK;AAEF,MAAMC,eAAeR,KAAKS,OAAO,CAACC,YAAYR;AAC9C,mGAAmG;AACnG,MAAMS,gBAAgBX,KAAKS,OAAO,CAACC,YAAYL;AAE/C;;;;;;;CAOC,GACD,SAASO,oBAAoBC,UAAmB;IAC9C,IAAIA,YAAY;QACd,OAAOb,KAAKM,IAAI,CAACK,eAAeE;IAClC;IACA,OAAOF;AACT;AACAG,QAAQC,SAAS,CAACC,CAAC,GAAGJ","ignoreList":[0]}},
     {"offset": {"line": 566, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/node-wasm-utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../shared/runtime-utils.ts\" />\n\nfunction readWebAssemblyAsResponse(path: string) {\n  const { createReadStream } = require('fs') as typeof import('fs')\n  const { Readable } = require('stream') as typeof import('stream')\n\n  const stream = createReadStream(path)\n\n  // @ts-ignore unfortunately there's a slight type mismatch with the stream.\n  return new Response(Readable.toWeb(stream), {\n    headers: {\n      'content-type': 'application/wasm',\n    },\n  })\n}\n\nasync function compileWebAssemblyFromPath(\n  path: string\n): Promise<WebAssembly.Module> {\n  const response = readWebAssemblyAsResponse(path)\n\n  return await WebAssembly.compileStreaming(response)\n}\n\nasync function instantiateWebAssemblyFromPath(\n  path: string,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  const response = readWebAssemblyAsResponse(path)\n\n  const { instance } = await WebAssembly.instantiateStreaming(\n    response,\n    importsObj\n  )\n\n  return instance.exports\n}\n"],"names":["readWebAssemblyAsResponse","path","createReadStream","require","Readable","stream","Response","toWeb","headers","compileWebAssemblyFromPath","response","WebAssembly","compileStreaming","instantiateWebAssemblyFromPath","importsObj","instance","instantiateStreaming","exports"],"mappings":"AAAA,oDAAoD,GAEpD,mDAAmD;AAEnD,SAASA,0BAA0BC,IAAY;IAC7C,MAAM,EAAEC,gBAAgB,EAAE,GAAGC,QAAQ;IACrC,MAAM,EAAEC,QAAQ,EAAE,GAAGD,QAAQ;IAE7B,MAAME,SAASH,iBAAiBD;IAEhC,2EAA2E;IAC3E,OAAO,IAAIK,SAASF,SAASG,KAAK,CAACF,SAAS;QAC1CG,SAAS;YACP,gBAAgB;QAClB;IACF;AACF;AAEA,eAAeC,2BACbR,IAAY;IAEZ,MAAMS,WAAWV,0BAA0BC;IAE3C,OAAO,MAAMU,YAAYC,gBAAgB,CAACF;AAC5C;AAEA,eAAeG,+BACbZ,IAAY,EACZa,UAA+B;IAE/B,MAAMJ,WAAWV,0BAA0BC;IAE3C,MAAM,EAAEc,QAAQ,EAAE,GAAG,MAAMJ,YAAYK,oBAAoB,CACzDN,UACAI;IAGF,OAAOC,SAASE,OAAO;AACzB","ignoreList":[0]}},
-    {"offset": {"line": 587, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/nodejs/runtime.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../shared/runtime-utils.ts\" />\n/// <reference path=\"../shared-node/base-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-wasm-utils.ts\" />\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n}\n\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext<Module> {\n  R: ResolvePathFromModule\n  x: ExternalRequire\n  y: ExternalImport\n}\n\nconst nodeContextPrototype = Context.prototype as TurbopackNodeBuildContext\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackNodeBuildContext\n) => unknown\n\nconst url = require('url') as typeof import('url')\n\nconst moduleFactories: ModuleFactories = new Map()\nnodeContextPrototype.M = moduleFactories\nconst moduleCache: ModuleCache<Module> = Object.create(null)\nnodeContextPrototype.c = moduleCache\n\n/**\n * Returns an absolute path to the given module's id.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  const exportedPath = exported?.default ?? exported\n  if (typeof exportedPath !== 'string') {\n    return exported as any\n  }\n\n  const strippedAssetPrefix = exportedPath.slice(ASSET_PREFIX.length)\n  const resolved = path.resolve(RUNTIME_ROOT, strippedAssetPrefix)\n\n  return url.pathToFileURL(resolved).href\n}\nnodeContextPrototype.R = resolvePathFromModule\n\nfunction loadRuntimeChunk(sourcePath: ChunkPath, chunkData: ChunkData): void {\n  if (typeof chunkData === 'string') {\n    loadRuntimeChunkPath(sourcePath, chunkData)\n  } else {\n    loadRuntimeChunkPath(sourcePath, chunkData.path)\n  }\n}\n\nconst loadedChunks = new Set<ChunkPath>()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise<void> = Promise.resolve(undefined)\nconst chunkCache = new Map<ChunkPath, Promise<void>>()\n\nfunction clearChunkCache() {\n  chunkCache.clear()\n}\n\nfunction loadRuntimeChunkPath(\n  sourcePath: ChunkPath,\n  chunkPath: ChunkPath\n): void {\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return\n  }\n\n  if (loadedChunks.has(chunkPath)) {\n    return\n  }\n\n  try {\n    const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n    const chunkModules: CompressedModuleFactories = require(resolved)\n    installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n    loadedChunks.add(chunkPath)\n  } catch (cause) {\n    let errorMessage = `Failed to load chunk ${chunkPath}`\n\n    if (sourcePath) {\n      errorMessage += ` from runtime for chunk ${sourcePath}`\n    }\n\n    const error = new Error(errorMessage, { cause })\n    error.name = 'ChunkLoadError'\n    throw error\n  }\n}\n\nfunction loadChunkAsync(\n  this: TurbopackBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  const chunkPath = typeof chunkData === 'string' ? chunkData : chunkData.path\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return unsupportedLoadChunk\n  }\n\n  let entry = chunkCache.get(chunkPath)\n  if (entry === undefined) {\n    try {\n      // resolve to an absolute path to simplify `require` handling\n      const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n      // TODO: consider switching to `import()` to enable concurrent chunk loading and async file io\n      // However this is incompatible with hot reloading (since `import` doesn't use the require cache)\n      const chunkModules: CompressedModuleFactories = require(resolved)\n      installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n      entry = loadedChunk\n    } catch (cause) {\n      const errorMessage = `Failed to load chunk ${chunkPath} from module ${this.m.id}`\n      const error = new Error(errorMessage, { cause })\n      error.name = 'ChunkLoadError'\n\n      // Cache the failure promise, future requests will also get this same rejection\n      entry = Promise.reject(error)\n    }\n    chunkCache.set(chunkPath, entry)\n  }\n  // TODO: Return an instrumented Promise that React can use instead of relying on referential equality.\n  return entry\n}\ncontextPrototype.l = loadChunkAsync\n\nfunction loadChunkAsyncByUrl(\n  this: TurbopackBaseContext<Module>,\n  chunkUrl: string\n) {\n  const path = url.fileURLToPath(new URL(chunkUrl, RUNTIME_ROOT)) as ChunkPath\n  return loadChunkAsync.call(this, path)\n}\ncontextPrototype.L = loadChunkAsyncByUrl\n\nfunction loadWebAssembly(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module,\n  imports: WebAssembly.Imports\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return instantiateWebAssemblyFromPath(resolved, imports)\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return compileWebAssemblyFromPath(resolved)\n}\ncontextPrototype.u = loadWebAssemblyModule\n\nfunction getWorkerBlobURL(_chunks: ChunkPath[]): string {\n  throw new Error('Worker blobs are not implemented yet for Node.js')\n}\n\nnodeContextPrototype.b = getWorkerBlobURL\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    let instantiationReason: string\n    switch (sourceType) {\n      case SourceType.Runtime:\n        instantiationReason = `as a runtime entry of chunk ${sourceData}`\n        break\n      case SourceType.Parent:\n        instantiationReason = `because it was required from module ${sourceData}`\n        break\n      default:\n        invariant(\n          sourceType,\n          (sourceType) => `Unknown source type: ${sourceType}`\n        )\n    }\n    throw new Error(\n      `Module ${id} was instantiated ${instantiationReason}, but the module factory is not available.`\n    )\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n  moduleCache[id] = module\n\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  module.loaded = true\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore\nfunction getOrInstantiateModuleFromParent(\n  id: ModuleId,\n  sourceModule: Module\n): Module {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it as a runtime module if it is not cached.\n */\n// @ts-ignore TypeScript doesn't separate this module space from the browser runtime\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateRuntimeModule(chunkPath, moduleId)\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nmodule.exports = (sourcePath: ChunkPath) => ({\n  m: (id: ModuleId) => getOrInstantiateRuntimeModule(sourcePath, id),\n  c: (chunkData: ChunkData) => loadRuntimeChunk(sourcePath, chunkData),\n})\n"],"names":["SourceType","process","env","TURBOPACK","nodeContextPrototype","Context","prototype","url","require","moduleFactories","Map","M","moduleCache","Object","create","c","resolvePathFromModule","moduleId","exported","r","exportedPath","default","strippedAssetPrefix","slice","ASSET_PREFIX","length","resolved","path","resolve","RUNTIME_ROOT","pathToFileURL","href","R","loadRuntimeChunk","sourcePath","chunkData","loadRuntimeChunkPath","loadedChunks","Set","unsupportedLoadChunk","Promise","undefined","loadedChunk","chunkCache","clearChunkCache","clear","chunkPath","isJs","has","chunkModules","installCompressedModuleFactories","add","cause","errorMessage","error","Error","name","loadChunkAsync","entry","get","m","id","reject","set","contextPrototype","l","loadChunkAsyncByUrl","chunkUrl","path1","fileURLToPath","URL","call","L","loadWebAssembly","_edgeModule","imports","instantiateWebAssemblyFromPath","w","loadWebAssemblyModule","compileWebAssemblyFromPath","u","getWorkerBlobURL","_chunks","b","instantiateModule","sourceType","sourceData","moduleFactory","instantiationReason","invariant","module1","createModuleObject","exports","context","loaded","namespaceObject","interopEsm","getOrInstantiateModuleFromParent","sourceModule","instantiateRuntimeModule","getOrInstantiateRuntimeModule","regexJsUrl","chunkUrlOrPath","test","module"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 587, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/nodejs/runtime.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../shared/runtime-utils.ts\" />\n/// <reference path=\"../shared-node/base-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-wasm-utils.ts\" />\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n}\n\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext<Module> {\n  R: ResolvePathFromModule\n  x: ExternalRequire\n  y: ExternalImport\n}\n\nconst nodeContextPrototype = Context.prototype as TurbopackNodeBuildContext\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackNodeBuildContext\n) => unknown\n\nconst url = require('url') as typeof import('url')\n\nconst moduleFactories: ModuleFactories = new Map()\nnodeContextPrototype.M = moduleFactories\nconst moduleCache: ModuleCache<Module> = Object.create(null)\nnodeContextPrototype.c = moduleCache\n\n/**\n * Returns an absolute path to the given module's id.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  const exportedPath = exported?.default ?? exported\n  if (typeof exportedPath !== 'string') {\n    return exported as any\n  }\n\n  const strippedAssetPrefix = exportedPath.slice(ASSET_PREFIX.length)\n  const resolved = path.resolve(RUNTIME_ROOT, strippedAssetPrefix)\n\n  return url.pathToFileURL(resolved).href\n}\nnodeContextPrototype.R = resolvePathFromModule\n\nfunction loadRuntimeChunk(sourcePath: ChunkPath, chunkData: ChunkData): void {\n  if (typeof chunkData === 'string') {\n    loadRuntimeChunkPath(sourcePath, chunkData)\n  } else {\n    loadRuntimeChunkPath(sourcePath, chunkData.path)\n  }\n}\n\nconst loadedChunks = new Set<ChunkPath>()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise<void> = Promise.resolve(undefined)\nconst chunkCache = new Map<ChunkPath, Promise<void>>()\n\nfunction clearChunkCache() {\n  chunkCache.clear()\n}\n\nfunction loadRuntimeChunkPath(\n  sourcePath: ChunkPath,\n  chunkPath: ChunkPath\n): void {\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return\n  }\n\n  if (loadedChunks.has(chunkPath)) {\n    return\n  }\n\n  try {\n    const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n    const chunkModules: CompressedModuleFactories = require(resolved)\n    installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n    loadedChunks.add(chunkPath)\n  } catch (cause) {\n    let errorMessage = `Failed to load chunk ${chunkPath}`\n\n    if (sourcePath) {\n      errorMessage += ` from runtime for chunk ${sourcePath}`\n    }\n\n    const error = new Error(errorMessage, { cause })\n    error.name = 'ChunkLoadError'\n    throw error\n  }\n}\n\nfunction loadChunkAsync(\n  this: TurbopackBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  const chunkPath = typeof chunkData === 'string' ? chunkData : chunkData.path\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return unsupportedLoadChunk\n  }\n\n  let entry = chunkCache.get(chunkPath)\n  if (entry === undefined) {\n    try {\n      // resolve to an absolute path to simplify `require` handling\n      const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n      // TODO: consider switching to `import()` to enable concurrent chunk loading and async file io\n      // However this is incompatible with hot reloading (since `import` doesn't use the require cache)\n      const chunkModules: CompressedModuleFactories = require(resolved)\n      installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n      entry = loadedChunk\n    } catch (cause) {\n      const errorMessage = `Failed to load chunk ${chunkPath} from module ${this.m.id}`\n      const error = new Error(errorMessage, { cause })\n      error.name = 'ChunkLoadError'\n\n      // Cache the failure promise, future requests will also get this same rejection\n      entry = Promise.reject(error)\n    }\n    chunkCache.set(chunkPath, entry)\n  }\n  // TODO: Return an instrumented Promise that React can use instead of relying on referential equality.\n  return entry\n}\ncontextPrototype.l = loadChunkAsync\n\nfunction loadChunkAsyncByUrl(\n  this: TurbopackBaseContext<Module>,\n  chunkUrl: string\n) {\n  const path = url.fileURLToPath(new URL(chunkUrl, RUNTIME_ROOT)) as ChunkPath\n  return loadChunkAsync.call(this, path)\n}\ncontextPrototype.L = loadChunkAsyncByUrl\n\nfunction loadWebAssembly(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module,\n  imports: WebAssembly.Imports\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return instantiateWebAssemblyFromPath(resolved, imports)\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return compileWebAssemblyFromPath(resolved)\n}\ncontextPrototype.u = loadWebAssemblyModule\n\nfunction getWorkerURL(\n  _entrypoint: ChunkPath,\n  _moduleChunks: ChunkPath[],\n  _shared: boolean\n): URL {\n  throw new Error('Worker urls are not implemented yet for Node.js')\n}\n\nnodeContextPrototype.b = getWorkerURL\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    let instantiationReason: string\n    switch (sourceType) {\n      case SourceType.Runtime:\n        instantiationReason = `as a runtime entry of chunk ${sourceData}`\n        break\n      case SourceType.Parent:\n        instantiationReason = `because it was required from module ${sourceData}`\n        break\n      default:\n        invariant(\n          sourceType,\n          (sourceType) => `Unknown source type: ${sourceType}`\n        )\n    }\n    throw new Error(\n      `Module ${id} was instantiated ${instantiationReason}, but the module factory is not available.`\n    )\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n  moduleCache[id] = module\n\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  module.loaded = true\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore\nfunction getOrInstantiateModuleFromParent(\n  id: ModuleId,\n  sourceModule: Module\n): Module {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it as a runtime module if it is not cached.\n */\n// @ts-ignore TypeScript doesn't separate this module space from the browser runtime\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateRuntimeModule(chunkPath, moduleId)\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nmodule.exports = (sourcePath: ChunkPath) => ({\n  m: (id: ModuleId) => getOrInstantiateRuntimeModule(sourcePath, id),\n  c: (chunkData: ChunkData) => loadRuntimeChunk(sourcePath, chunkData),\n})\n"],"names":["SourceType","process","env","TURBOPACK","nodeContextPrototype","Context","prototype","url","require","moduleFactories","Map","M","moduleCache","Object","create","c","resolvePathFromModule","moduleId","exported","r","exportedPath","default","strippedAssetPrefix","slice","ASSET_PREFIX","length","resolved","path","resolve","RUNTIME_ROOT","pathToFileURL","href","R","loadRuntimeChunk","sourcePath","chunkData","loadRuntimeChunkPath","loadedChunks","Set","unsupportedLoadChunk","Promise","undefined","loadedChunk","chunkCache","clearChunkCache","clear","chunkPath","isJs","has","chunkModules","installCompressedModuleFactories","add","cause","errorMessage","error","Error","name","loadChunkAsync","entry","get","m","id","reject","set","contextPrototype","l","loadChunkAsyncByUrl","chunkUrl","path1","fileURLToPath","URL","call","L","loadWebAssembly","_edgeModule","imports","instantiateWebAssemblyFromPath","w","loadWebAssemblyModule","compileWebAssemblyFromPath","u","getWorkerURL","_entrypoint","_moduleChunks","_shared","b","instantiateModule","sourceType","sourceData","moduleFactory","instantiationReason","invariant","module1","createModuleObject","exports","context","loaded","namespaceObject","interopEsm","getOrInstantiateModuleFromParent","sourceModule","instantiateRuntimeModule","getOrInstantiateRuntimeModule","regexJsUrl","chunkUrlOrPath","test","module"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/6642e_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/6642e_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js
new file mode 100644
index 00000000000000..090f4d2a32ce21
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/6642e_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js
@@ -0,0 +1,62 @@
+/**
+ * Worker entrypoint bootstrap.
+ */ ;
+(()=>{
+    function abort(message) {
+        console.error(message);
+        throw new Error(message);
+    }
+    // Security: Ensure this code is running in a worker environment to prevent
+    // the worker entrypoint being used as an XSS gadget. If this is a worker, we
+    // know that the origin of the caller is the same as our origin.
+    if (typeof self['WorkerGlobalScope'] === 'undefined' || !(self instanceof self['WorkerGlobalScope'])) {
+        abort('Worker entrypoint must be loaded in a worker context');
+    }
+    const url = new URL(location.href);
+    // Try querystring first (SharedWorker), then hash (regular Worker)
+    let paramsString = url.searchParams.get('params');
+    if (!paramsString && url.hash.startsWith('#params=')) {
+        paramsString = decodeURIComponent(url.hash.slice('#params='.length));
+    }
+    if (!paramsString) abort('Missing worker bootstrap config');
+    // Safety: this string requires that a script on the same origin has loaded
+    // this code as a module. We still don't fully trust it, so we'll validate the
+    // types and ensure that the next chunk URLs are same-origin.
+    const config = JSON.parse(paramsString);
+    const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : '';
+    const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : '';
+    // In a normal browser context, the runtime can figure out which chunk is
+    // currently executing via `document.currentScript`. Workers don't have that
+    // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead
+    // (`reverse()`d below).
+    //
+    // Each chunk pops its URL off the front of the array when it runs, so we need
+    // to store them in reverse order to make sure the first chunk to execute sees
+    // its own URL at the front.
+    const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : [];
+    Object.assign(self, {
+        TURBOPACK_CHUNK_SUFFIX,
+        TURBOPACK_NEXT_CHUNK_URLS,
+        NEXT_DEPLOYMENT_ID
+    });
+    if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+        const scriptsToLoad = [];
+        for (const chunk of TURBOPACK_NEXT_CHUNK_URLS){
+            // Chunks are relative to the origin.
+            const chunkUrl = new URL(chunk, location.origin);
+            // Security: Only load scripts from the same origin. This prevents this
+            // worker entrypoint from being used as a gadget to load scripts from
+            // foreign origins if someone happens to find a separate XSS vector
+            // elsewhere on this origin.
+            if (chunkUrl.origin !== location.origin) {
+                abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`);
+            }
+            scriptsToLoad.push(chunkUrl.toString());
+        }
+        TURBOPACK_NEXT_CHUNK_URLS.reverse();
+        importScripts(...scriptsToLoad);
+    }
+})();
+
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js
index 3dd9ff7edd4fc9..f2eefc0b01d081 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js
@@ -8,10 +8,7 @@ module.exports = 'turbopack';
 __turbopack_context__.v("/static/vercel.242d4ff2.cjs");}),
 "[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/vercel.cjs [test] (ecmascript, worker loader)", ((__turbopack_context__) => {
 
-__turbopack_context__.v(__turbopack_context__.b([
-  "output/bf321_tests_snapshot_imports_ignore-comments_input_vercel_cjs_422a38f6._.js",
-  "output/ad3e4_tests_snapshot_imports_ignore-comments_input_vercel_cjs_6f11dd5d._.js"
-]));
+__turbopack_context__.v(__turbopack_context__.b("output/6642e_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js", ["output/bf321_tests_snapshot_imports_ignore-comments_input_vercel_cjs_422a38f6._.js","output/ad3e4_tests_snapshot_imports_ignore-comments_input_vercel_cjs_6f11dd5d._.js"], false));
 }),
 "[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/ignore-worker.cjs (static in ecmascript)", ((__turbopack_context__) => {
 
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js.map
index 0edb354b2009c6..5a9dc61aa7931b 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_input_1f8151c3._.js.map
@@ -3,5 +3,5 @@
   "sources": [],
   "sections": [
     {"offset": {"line": 3, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/vercel.cjs"],"sourcesContent":["module.exports = 'turbopack'\n"],"names":["module","exports"],"mappings":"AAAAA,OAAOC,OAAO,GAAG"}},
-    {"offset": {"line": 21, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/index.js"],"sourcesContent":["import('./vercel.mjs').then(console.log)\nimport(/* webpackIgnore: false */ './vercel.mjs').then(console.log)\nconsole.log(require('./vercel.cjs'))\nnew Worker(\n  /* turbopackIgnore: false */ new URL('./vercel.cjs', import.meta.url)\n)\n\n// turbopack shouldn't attempt to bundle these, and they should be preserved in the output\nimport(/* webpackIgnore: true */ './ignore.mjs')\nimport(/* turbopackIgnore: true */ './ignore.mjs')\n\n// this should work for cjs requires too\nrequire(/* webpackIgnore: true */ './ignore.cjs')\nrequire(/* turbopackIgnore: true */ './ignore.cjs')\n\nnew Worker(\n  /* turbopackIgnore: true */ new URL('./ignore-worker.cjs', import.meta.url)\n)\nnew Worker(\n  /* webpackIgnore: true */ new URL('./ignore-worker.cjs', import.meta.url)\n)\n\nexport function foo(plugin) {\n  return require(/* turbopackIgnore: true */ plugin)\n}\n"],"names":["then","console","log","Worker","require","foo","plugin"],"mappings":";;;;;;;;;AAAA,gKAAuBA,IAAI,CAACC,QAAQC,GAAG;AACvC,gKAAkDF,IAAI,CAACC,QAAQC,GAAG;AAClED,QAAQC,GAAG;AACX,IAAIC;AAIJ,0FAA0F;AAC1F,MAAM,CAAC,uBAAuB,GAAG;AACjC,MAAM,CAAC,yBAAyB,GAAG;AAEnC,wCAAwC;AACxCC,QAAQ,uBAAuB,GAAG;AAClCA,QAAQ,yBAAyB,GAAG;AAEpC,IAAID;AAGJ,IAAIA;AAIG,SAASE,IAAIC,MAAM;IACxB,OAAOF,QAAQ,yBAAyB,GAAGE;AAC7C"}}]
+    {"offset": {"line": 18, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/index.js"],"sourcesContent":["import('./vercel.mjs').then(console.log)\nimport(/* webpackIgnore: false */ './vercel.mjs').then(console.log)\nconsole.log(require('./vercel.cjs'))\nnew Worker(\n  /* turbopackIgnore: false */ new URL('./vercel.cjs', import.meta.url)\n)\n\n// turbopack shouldn't attempt to bundle these, and they should be preserved in the output\nimport(/* webpackIgnore: true */ './ignore.mjs')\nimport(/* turbopackIgnore: true */ './ignore.mjs')\n\n// this should work for cjs requires too\nrequire(/* webpackIgnore: true */ './ignore.cjs')\nrequire(/* turbopackIgnore: true */ './ignore.cjs')\n\nnew Worker(\n  /* turbopackIgnore: true */ new URL('./ignore-worker.cjs', import.meta.url)\n)\nnew Worker(\n  /* webpackIgnore: true */ new URL('./ignore-worker.cjs', import.meta.url)\n)\n\nexport function foo(plugin) {\n  return require(/* turbopackIgnore: true */ plugin)\n}\n"],"names":["then","console","log","Worker","require","foo","plugin"],"mappings":";;;;;;;;;AAAA,gKAAuBA,IAAI,CAACC,QAAQC,GAAG;AACvC,gKAAkDF,IAAI,CAACC,QAAQC,GAAG;AAClED,QAAQC,GAAG;AACX,IAAIC;AAIJ,0FAA0F;AAC1F,MAAM,CAAC,uBAAuB,GAAG;AACjC,MAAM,CAAC,yBAAyB,GAAG;AAEnC,wCAAwC;AACxCC,QAAQ,uBAAuB,GAAG;AAClCA,QAAQ,yBAAyB,GAAG;AAEpC,IAAID;AAGJ,IAAIA;AAIG,SAASE,IAAIC,MAAM;IACxB,OAAOF,QAAQ,yBAAyB,GAAGE;AAC7C"}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js.map
new file mode 100644
index 00000000000000..0470b96a8e80b4
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/output/aaf3a_crates_turbopack-tests_tests_snapshot_imports_ignore-comments_output_2867ca5f._.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/worker-entrypoint.ts"],"sourcesContent":["/**\n * Worker entrypoint bootstrap.\n */\n\ninterface WorkerBootstrapConfig {\n  // TURBOPACK_CHUNK_SUFFIX\n  S?: string\n  // NEXT_DEPLOYMENT_ID\n  N?: string\n  // TURBOPACK_NEXT_CHUNK_URLS\n  NC?: string[]\n}\n\n;(() => {\n  function abort(message: string): never {\n    console.error(message)\n    throw new Error(message)\n  }\n\n  // Security: Ensure this code is running in a worker environment to prevent\n  // the worker entrypoint being used as an XSS gadget. If this is a worker, we\n  // know that the origin of the caller is the same as our origin.\n  if (\n    typeof (self as any)['WorkerGlobalScope'] === 'undefined' ||\n    !(self instanceof (self as any)['WorkerGlobalScope'])\n  ) {\n    abort('Worker entrypoint must be loaded in a worker context')\n  }\n\n  const url = new URL(location.href)\n\n  // Try querystring first (SharedWorker), then hash (regular Worker)\n  let paramsString = url.searchParams.get('params')\n  if (!paramsString && url.hash.startsWith('#params=')) {\n    paramsString = decodeURIComponent(url.hash.slice('#params='.length))\n  }\n\n  if (!paramsString) abort('Missing worker bootstrap config')\n\n  // Safety: this string requires that a script on the same origin has loaded\n  // this code as a module. We still don't fully trust it, so we'll validate the\n  // types and ensure that the next chunk URLs are same-origin.\n  const config: WorkerBootstrapConfig = JSON.parse(paramsString)\n\n  const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : ''\n  const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : ''\n  // In a normal browser context, the runtime can figure out which chunk is\n  // currently executing via `document.currentScript`. Workers don't have that\n  // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead\n  // (`reverse()`d below).\n  //\n  // Each chunk pops its URL off the front of the array when it runs, so we need\n  // to store them in reverse order to make sure the first chunk to execute sees\n  // its own URL at the front.\n  const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : []\n\n  Object.assign(self, {\n    TURBOPACK_CHUNK_SUFFIX,\n    TURBOPACK_NEXT_CHUNK_URLS,\n    NEXT_DEPLOYMENT_ID,\n  })\n\n  if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {\n    const scriptsToLoad: string[] = []\n    for (const chunk of TURBOPACK_NEXT_CHUNK_URLS) {\n      // Chunks are relative to the origin.\n      const chunkUrl = new URL(chunk, location.origin)\n      // Security: Only load scripts from the same origin. This prevents this\n      // worker entrypoint from being used as a gadget to load scripts from\n      // foreign origins if someone happens to find a separate XSS vector\n      // elsewhere on this origin.\n      if (chunkUrl.origin !== location.origin) {\n        abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`)\n      }\n      scriptsToLoad.push(chunkUrl.toString())\n    }\n\n    TURBOPACK_NEXT_CHUNK_URLS.reverse()\n    importScripts(...scriptsToLoad)\n  }\n})()\n"],"names":["abort","message","console","error","Error","self","url","URL","location","href","paramsString","searchParams","get","hash","startsWith","decodeURIComponent","slice","length","config","JSON","parse","TURBOPACK_CHUNK_SUFFIX","S","NEXT_DEPLOYMENT_ID","N","TURBOPACK_NEXT_CHUNK_URLS","Array","isArray","NC","Object","assign","scriptsToLoad","chunk","chunkUrl","origin","push","toString","reverse","importScripts"],"mappings":"AAAA;;CAEC;AAWA,CAAC;IACA,SAASA,MAAMC,OAAe;QAC5BC,QAAQC,KAAK,CAACF;QACd,MAAM,IAAIG,MAAMH;IAClB;IAEA,2EAA2E;IAC3E,6EAA6E;IAC7E,gEAAgE;IAChE,IACE,OAAO,AAACI,IAAY,CAAC,oBAAoB,KAAK,eAC9C,CAAC,CAACA,gBAAgB,AAACA,IAAY,CAAC,oBAAoB,GACpD;QACAL,MAAM;IACR;IAEA,MAAMM,MAAM,IAAIC,IAAIC,SAASC,IAAI;IAEjC,mEAAmE;IACnE,IAAIC,eAAeJ,IAAIK,YAAY,CAACC,GAAG,CAAC;IACxC,IAAI,CAACF,gBAAgBJ,IAAIO,IAAI,CAACC,UAAU,CAAC,aAAa;QACpDJ,eAAeK,mBAAmBT,IAAIO,IAAI,CAACG,KAAK,CAAC,WAAWC,MAAM;IACpE;IAEA,IAAI,CAACP,cAAcV,MAAM;IAEzB,2EAA2E;IAC3E,8EAA8E;IAC9E,6DAA6D;IAC7D,MAAMkB,SAAgCC,KAAKC,KAAK,CAACV;IAEjD,MAAMW,yBAAyB,OAAOH,OAAOI,CAAC,KAAK,WAAWJ,OAAOI,CAAC,GAAG;IACzE,MAAMC,qBAAqB,OAAOL,OAAOM,CAAC,KAAK,WAAWN,OAAOM,CAAC,GAAG;IACrE,yEAAyE;IACzE,4EAA4E;IAC5E,mEAAmE;IACnE,wBAAwB;IACxB,EAAE;IACF,8EAA8E;IAC9E,8EAA8E;IAC9E,4BAA4B;IAC5B,MAAMC,4BAA4BC,MAAMC,OAAO,CAACT,OAAOU,EAAE,IAAIV,OAAOU,EAAE,GAAG,EAAE;IAE3EC,OAAOC,MAAM,CAACzB,MAAM;QAClBgB;QACAI;QACAF;IACF;IAEA,IAAIE,0BAA0BR,MAAM,GAAG,GAAG;QACxC,MAAMc,gBAA0B,EAAE;QAClC,KAAK,MAAMC,SAASP,0BAA2B;YAC7C,qCAAqC;YACrC,MAAMQ,WAAW,IAAI1B,IAAIyB,OAAOxB,SAAS0B,MAAM;YAC/C,uEAAuE;YACvE,qEAAqE;YACrE,mEAAmE;YACnE,4BAA4B;YAC5B,IAAID,SAASC,MAAM,KAAK1B,SAAS0B,MAAM,EAAE;gBACvClC,MAAM,CAAC,6CAA6C,EAAEiC,SAASC,MAAM,EAAE;YACzE;YACAH,cAAcI,IAAI,CAACF,SAASG,QAAQ;QACtC;QAEAX,0BAA0BY,OAAO;QACjCC,iBAAiBP;IACnB;AACF,CAAC","ignoreList":[0]}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js
index 8c379dd9a48a59..e57476f4287657 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js
@@ -708,10 +708,10 @@ function loadWebAssemblyModule(chunkPath, _edgeModule) {
     return compileWebAssemblyFromPath(resolved);
 }
 contextPrototype.u = loadWebAssemblyModule;
-function getWorkerBlobURL(_chunks) {
-    throw new Error('Worker blobs are not implemented yet for Node.js');
+function getWorkerURL(_entrypoint, _moduleChunks, _shared) {
+    throw new Error('Worker urls are not implemented yet for Node.js');
 }
-nodeContextPrototype.b = getWorkerBlobURL;
+nodeContextPrototype.b = getWorkerURL;
 function instantiateModule(id, sourceType, sourceData) {
     const moduleFactory = moduleFactories.get(id);
     if (typeof moduleFactory !== 'function') {
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js.map
index 7c103f1960f712..437e87e489e4ff 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js.map
@@ -6,5 +6,5 @@
     {"offset": {"line": 504, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/base-externals-utils.ts"],"sourcesContent":["/// <reference path=\"../shared/runtime-utils.ts\" />\n\n/// A 'base' utilities to support runtime can have externals.\n/// Currently this is for node.js / edge runtime both.\n/// If a fn requires node.js specific behavior, it should be placed in `node-external-utils` instead.\n\nasync function externalImport(id: DependencySpecifier) {\n  let raw\n  try {\n    raw = await import(id)\n  } catch (err) {\n    // TODO(alexkirsz) This can happen when a client-side module tries to load\n    // an external module we don't provide a shim for (e.g. querystring, url).\n    // For now, we fail semi-silently, but in the future this should be a\n    // compilation error.\n    throw new Error(`Failed to load external module ${id}: ${err}`)\n  }\n\n  if (raw && raw.__esModule && raw.default && 'default' in raw.default) {\n    return interopEsm(raw.default, createNS(raw), true)\n  }\n\n  return raw\n}\ncontextPrototype.y = externalImport\n\nfunction externalRequire(\n  id: ModuleId,\n  thunk: () => any,\n  esm: boolean = false\n): Exports | EsmNamespaceObject {\n  let raw\n  try {\n    raw = thunk()\n  } catch (err) {\n    // TODO(alexkirsz) This can happen when a client-side module tries to load\n    // an external module we don't provide a shim for (e.g. querystring, url).\n    // For now, we fail semi-silently, but in the future this should be a\n    // compilation error.\n    throw new Error(`Failed to load external module ${id}: ${err}`)\n  }\n\n  if (!esm || raw.__esModule) {\n    return raw\n  }\n\n  return interopEsm(raw, createNS(raw), true)\n}\n\nexternalRequire.resolve = (\n  id: string,\n  options?: {\n    paths?: string[]\n  }\n) => {\n  return require.resolve(id, options)\n}\ncontextPrototype.x = externalRequire\n"],"names":["externalImport","id","raw","err","Error","__esModule","default","interopEsm","createNS","contextPrototype","y","externalRequire","thunk","esm","resolve","options","require","x"],"mappings":"AAAA,mDAAmD;AAEnD,6DAA6D;AAC7D,sDAAsD;AACtD,qGAAqG;AAErG,eAAeA,eAAeC,EAAuB;IACnD,IAAIC;IACJ,IAAI;QACFA,MAAM,MAAM,MAAM,CAACD;IACrB,EAAE,OAAOE,KAAK;QACZ,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,qBAAqB;QACrB,MAAM,IAAIC,MAAM,CAAC,+BAA+B,EAAEH,GAAG,EAAE,EAAEE,KAAK;IAChE;IAEA,IAAID,OAAOA,IAAIG,UAAU,IAAIH,IAAII,OAAO,IAAI,aAAaJ,IAAII,OAAO,EAAE;QACpE,OAAOC,WAAWL,IAAII,OAAO,EAAEE,SAASN,MAAM;IAChD;IAEA,OAAOA;AACT;AACAO,iBAAiBC,CAAC,GAAGV;AAErB,SAASW,gBACPV,EAAY,EACZW,KAAgB,EAChBC,MAAe,KAAK;IAEpB,IAAIX;IACJ,IAAI;QACFA,MAAMU;IACR,EAAE,OAAOT,KAAK;QACZ,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,qBAAqB;QACrB,MAAM,IAAIC,MAAM,CAAC,+BAA+B,EAAEH,GAAG,EAAE,EAAEE,KAAK;IAChE;IAEA,IAAI,CAACU,OAAOX,IAAIG,UAAU,EAAE;QAC1B,OAAOH;IACT;IAEA,OAAOK,WAAWL,KAAKM,SAASN,MAAM;AACxC;AAEAS,gBAAgBG,OAAO,GAAG,CACxBb,IACAc;IAIA,OAAOC,QAAQF,OAAO,CAACb,IAAIc;AAC7B;AACAN,iBAAiBQ,CAAC,GAAGN","ignoreList":[0]}},
     {"offset": {"line": 545, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/node-externals-utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\ndeclare var RUNTIME_PUBLIC_PATH: string\ndeclare var RELATIVE_ROOT_PATH: string\ndeclare var ASSET_PREFIX: string\n\nconst path = require('path')\n\nconst relativePathToRuntimeRoot = path.relative(RUNTIME_PUBLIC_PATH, '.')\n// Compute the relative path to the `distDir`.\nconst relativePathToDistRoot = path.join(\n  relativePathToRuntimeRoot,\n  RELATIVE_ROOT_PATH\n)\nconst RUNTIME_ROOT = path.resolve(__filename, relativePathToRuntimeRoot)\n// Compute the absolute path to the root, by stripping distDir from the absolute path to this file.\nconst ABSOLUTE_ROOT = path.resolve(__filename, relativePathToDistRoot)\n\n/**\n * Returns an absolute path to the given module path.\n * Module path should be relative, either path to a file or a directory.\n *\n * This fn allows to calculate an absolute path for some global static values, such as\n * `__dirname` or `import.meta.url` that Turbopack will not embeds in compile time.\n * See ImportMetaBinding::code_generation for the usage.\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  if (modulePath) {\n    return path.join(ABSOLUTE_ROOT, modulePath)\n  }\n  return ABSOLUTE_ROOT\n}\nContext.prototype.P = resolveAbsolutePath\n"],"names":["path","require","relativePathToRuntimeRoot","relative","RUNTIME_PUBLIC_PATH","relativePathToDistRoot","join","RELATIVE_ROOT_PATH","RUNTIME_ROOT","resolve","__filename","ABSOLUTE_ROOT","resolveAbsolutePath","modulePath","Context","prototype","P"],"mappings":"AAAA,oDAAoD,GAMpD,MAAMA,OAAOC,QAAQ;AAErB,MAAMC,4BAA4BF,KAAKG,QAAQ,CAACC,qBAAqB;AACrE,8CAA8C;AAC9C,MAAMC,yBAAyBL,KAAKM,IAAI,CACtCJ,2BACAK;AAEF,MAAMC,eAAeR,KAAKS,OAAO,CAACC,YAAYR;AAC9C,mGAAmG;AACnG,MAAMS,gBAAgBX,KAAKS,OAAO,CAACC,YAAYL;AAE/C;;;;;;;CAOC,GACD,SAASO,oBAAoBC,UAAmB;IAC9C,IAAIA,YAAY;QACd,OAAOb,KAAKM,IAAI,CAACK,eAAeE;IAClC;IACA,OAAOF;AACT;AACAG,QAAQC,SAAS,CAACC,CAAC,GAAGJ","ignoreList":[0]}},
     {"offset": {"line": 566, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared-node/node-wasm-utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../shared/runtime-utils.ts\" />\n\nfunction readWebAssemblyAsResponse(path: string) {\n  const { createReadStream } = require('fs') as typeof import('fs')\n  const { Readable } = require('stream') as typeof import('stream')\n\n  const stream = createReadStream(path)\n\n  // @ts-ignore unfortunately there's a slight type mismatch with the stream.\n  return new Response(Readable.toWeb(stream), {\n    headers: {\n      'content-type': 'application/wasm',\n    },\n  })\n}\n\nasync function compileWebAssemblyFromPath(\n  path: string\n): Promise<WebAssembly.Module> {\n  const response = readWebAssemblyAsResponse(path)\n\n  return await WebAssembly.compileStreaming(response)\n}\n\nasync function instantiateWebAssemblyFromPath(\n  path: string,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  const response = readWebAssemblyAsResponse(path)\n\n  const { instance } = await WebAssembly.instantiateStreaming(\n    response,\n    importsObj\n  )\n\n  return instance.exports\n}\n"],"names":["readWebAssemblyAsResponse","path","createReadStream","require","Readable","stream","Response","toWeb","headers","compileWebAssemblyFromPath","response","WebAssembly","compileStreaming","instantiateWebAssemblyFromPath","importsObj","instance","instantiateStreaming","exports"],"mappings":"AAAA,oDAAoD,GAEpD,mDAAmD;AAEnD,SAASA,0BAA0BC,IAAY;IAC7C,MAAM,EAAEC,gBAAgB,EAAE,GAAGC,QAAQ;IACrC,MAAM,EAAEC,QAAQ,EAAE,GAAGD,QAAQ;IAE7B,MAAME,SAASH,iBAAiBD;IAEhC,2EAA2E;IAC3E,OAAO,IAAIK,SAASF,SAASG,KAAK,CAACF,SAAS;QAC1CG,SAAS;YACP,gBAAgB;QAClB;IACF;AACF;AAEA,eAAeC,2BACbR,IAAY;IAEZ,MAAMS,WAAWV,0BAA0BC;IAE3C,OAAO,MAAMU,YAAYC,gBAAgB,CAACF;AAC5C;AAEA,eAAeG,+BACbZ,IAAY,EACZa,UAA+B;IAE/B,MAAMJ,WAAWV,0BAA0BC;IAE3C,MAAM,EAAEc,QAAQ,EAAE,GAAG,MAAMJ,YAAYK,oBAAoB,CACzDN,UACAI;IAGF,OAAOC,SAASE,OAAO;AACzB","ignoreList":[0]}},
-    {"offset": {"line": 587, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/nodejs/runtime.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../shared/runtime-utils.ts\" />\n/// <reference path=\"../shared-node/base-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-wasm-utils.ts\" />\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n}\n\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext<Module> {\n  R: ResolvePathFromModule\n  x: ExternalRequire\n  y: ExternalImport\n}\n\nconst nodeContextPrototype = Context.prototype as TurbopackNodeBuildContext\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackNodeBuildContext\n) => unknown\n\nconst url = require('url') as typeof import('url')\n\nconst moduleFactories: ModuleFactories = new Map()\nnodeContextPrototype.M = moduleFactories\nconst moduleCache: ModuleCache<Module> = Object.create(null)\nnodeContextPrototype.c = moduleCache\n\n/**\n * Returns an absolute path to the given module's id.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  const exportedPath = exported?.default ?? exported\n  if (typeof exportedPath !== 'string') {\n    return exported as any\n  }\n\n  const strippedAssetPrefix = exportedPath.slice(ASSET_PREFIX.length)\n  const resolved = path.resolve(RUNTIME_ROOT, strippedAssetPrefix)\n\n  return url.pathToFileURL(resolved).href\n}\nnodeContextPrototype.R = resolvePathFromModule\n\nfunction loadRuntimeChunk(sourcePath: ChunkPath, chunkData: ChunkData): void {\n  if (typeof chunkData === 'string') {\n    loadRuntimeChunkPath(sourcePath, chunkData)\n  } else {\n    loadRuntimeChunkPath(sourcePath, chunkData.path)\n  }\n}\n\nconst loadedChunks = new Set<ChunkPath>()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise<void> = Promise.resolve(undefined)\nconst chunkCache = new Map<ChunkPath, Promise<void>>()\n\nfunction clearChunkCache() {\n  chunkCache.clear()\n}\n\nfunction loadRuntimeChunkPath(\n  sourcePath: ChunkPath,\n  chunkPath: ChunkPath\n): void {\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return\n  }\n\n  if (loadedChunks.has(chunkPath)) {\n    return\n  }\n\n  try {\n    const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n    const chunkModules: CompressedModuleFactories = require(resolved)\n    installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n    loadedChunks.add(chunkPath)\n  } catch (cause) {\n    let errorMessage = `Failed to load chunk ${chunkPath}`\n\n    if (sourcePath) {\n      errorMessage += ` from runtime for chunk ${sourcePath}`\n    }\n\n    const error = new Error(errorMessage, { cause })\n    error.name = 'ChunkLoadError'\n    throw error\n  }\n}\n\nfunction loadChunkAsync(\n  this: TurbopackBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  const chunkPath = typeof chunkData === 'string' ? chunkData : chunkData.path\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return unsupportedLoadChunk\n  }\n\n  let entry = chunkCache.get(chunkPath)\n  if (entry === undefined) {\n    try {\n      // resolve to an absolute path to simplify `require` handling\n      const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n      // TODO: consider switching to `import()` to enable concurrent chunk loading and async file io\n      // However this is incompatible with hot reloading (since `import` doesn't use the require cache)\n      const chunkModules: CompressedModuleFactories = require(resolved)\n      installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n      entry = loadedChunk\n    } catch (cause) {\n      const errorMessage = `Failed to load chunk ${chunkPath} from module ${this.m.id}`\n      const error = new Error(errorMessage, { cause })\n      error.name = 'ChunkLoadError'\n\n      // Cache the failure promise, future requests will also get this same rejection\n      entry = Promise.reject(error)\n    }\n    chunkCache.set(chunkPath, entry)\n  }\n  // TODO: Return an instrumented Promise that React can use instead of relying on referential equality.\n  return entry\n}\ncontextPrototype.l = loadChunkAsync\n\nfunction loadChunkAsyncByUrl(\n  this: TurbopackBaseContext<Module>,\n  chunkUrl: string\n) {\n  const path = url.fileURLToPath(new URL(chunkUrl, RUNTIME_ROOT)) as ChunkPath\n  return loadChunkAsync.call(this, path)\n}\ncontextPrototype.L = loadChunkAsyncByUrl\n\nfunction loadWebAssembly(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module,\n  imports: WebAssembly.Imports\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return instantiateWebAssemblyFromPath(resolved, imports)\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return compileWebAssemblyFromPath(resolved)\n}\ncontextPrototype.u = loadWebAssemblyModule\n\nfunction getWorkerBlobURL(_chunks: ChunkPath[]): string {\n  throw new Error('Worker blobs are not implemented yet for Node.js')\n}\n\nnodeContextPrototype.b = getWorkerBlobURL\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    let instantiationReason: string\n    switch (sourceType) {\n      case SourceType.Runtime:\n        instantiationReason = `as a runtime entry of chunk ${sourceData}`\n        break\n      case SourceType.Parent:\n        instantiationReason = `because it was required from module ${sourceData}`\n        break\n      default:\n        invariant(\n          sourceType,\n          (sourceType) => `Unknown source type: ${sourceType}`\n        )\n    }\n    throw new Error(\n      `Module ${id} was instantiated ${instantiationReason}, but the module factory is not available.`\n    )\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n  moduleCache[id] = module\n\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  module.loaded = true\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore\nfunction getOrInstantiateModuleFromParent(\n  id: ModuleId,\n  sourceModule: Module\n): Module {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it as a runtime module if it is not cached.\n */\n// @ts-ignore TypeScript doesn't separate this module space from the browser runtime\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateRuntimeModule(chunkPath, moduleId)\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nmodule.exports = (sourcePath: ChunkPath) => ({\n  m: (id: ModuleId) => getOrInstantiateRuntimeModule(sourcePath, id),\n  c: (chunkData: ChunkData) => loadRuntimeChunk(sourcePath, chunkData),\n})\n"],"names":["SourceType","process","env","TURBOPACK","nodeContextPrototype","Context","prototype","url","require","moduleFactories","Map","M","moduleCache","Object","create","c","resolvePathFromModule","moduleId","exported","r","exportedPath","default","strippedAssetPrefix","slice","ASSET_PREFIX","length","resolved","path","resolve","RUNTIME_ROOT","pathToFileURL","href","R","loadRuntimeChunk","sourcePath","chunkData","loadRuntimeChunkPath","loadedChunks","Set","unsupportedLoadChunk","Promise","undefined","loadedChunk","chunkCache","clearChunkCache","clear","chunkPath","isJs","has","chunkModules","installCompressedModuleFactories","add","cause","errorMessage","error","Error","name","loadChunkAsync","entry","get","m","id","reject","set","contextPrototype","l","loadChunkAsyncByUrl","chunkUrl","path1","fileURLToPath","URL","call","L","loadWebAssembly","_edgeModule","imports","instantiateWebAssemblyFromPath","w","loadWebAssemblyModule","compileWebAssemblyFromPath","u","getWorkerBlobURL","_chunks","b","instantiateModule","sourceType","sourceData","moduleFactory","instantiationReason","invariant","module1","createModuleObject","exports","context","loaded","namespaceObject","interopEsm","getOrInstantiateModuleFromParent","sourceModule","instantiateRuntimeModule","getOrInstantiateRuntimeModule","regexJsUrl","chunkUrlOrPath","test","module"],"mappings":"AAAA,oDAAoD,GAEpD,mDAAmD;AACnD,+DAA+D;AAC/D,+DAA+D;AAC/D,0DAA0D;AAE1D,IAAA,AAAKA,oCAAAA;IACH;;;;GAIC;IAED;;;GAGC;WAVEA;EAAAA;AAgBLC,QAAQC,GAAG,CAACC,SAAS,GAAG;AAQxB,MAAMC,uBAAuBC,QAAQC,SAAS;AAO9C,MAAMC,MAAMC,QAAQ;AAEpB,MAAMC,kBAAmC,IAAIC;AAC7CN,qBAAqBO,CAAC,GAAGF;AACzB,MAAMG,cAAmCC,OAAOC,MAAM,CAAC;AACvDV,qBAAqBW,CAAC,GAAGH;AAEzB;;CAEC,GACD,SAASI,sBAEPC,QAAgB;IAEhB,MAAMC,WAAW,IAAI,CAACC,CAAC,CAACF;IACxB,MAAMG,eAAeF,UAAUG,WAAWH;IAC1C,IAAI,OAAOE,iBAAiB,UAAU;QACpC,OAAOF;IACT;IAEA,MAAMI,sBAAsBF,aAAaG,KAAK,CAACC,aAAaC,MAAM;IAClE,MAAMC,WAAWC,KAAKC,OAAO,CAACC,cAAcP;IAE5C,OAAOf,IAAIuB,aAAa,CAACJ,UAAUK,IAAI;AACzC;AACA3B,qBAAqB4B,CAAC,GAAGhB;AAEzB,SAASiB,iBAAiBC,UAAqB,EAAEC,SAAoB;IACnE,IAAI,OAAOA,cAAc,UAAU;QACjCC,qBAAqBF,YAAYC;IACnC,OAAO;QACLC,qBAAqBF,YAAYC,UAAUR,IAAI;IACjD;AACF;AAEA,MAAMU,eAAe,IAAIC;AACzB,MAAMC,uBAAuBC,QAAQZ,OAAO,CAACa;AAC7C,MAAMC,cAA6BF,QAAQZ,OAAO,CAACa;AACnD,MAAME,aAAa,IAAIjC;AAEvB,SAASkC;IACPD,WAAWE,KAAK;AAClB;AAEA,SAAST,qBACPF,UAAqB,EACrBY,SAAoB;IAEpB,IAAI,CAACC,KAAKD,YAAY;QACpB,gDAAgD;QAChD,0DAA0D;QAC1D;IACF;IAEA,IAAIT,aAAaW,GAAG,CAACF,YAAY;QAC/B;IACF;IAEA,IAAI;QACF,MAAMpB,WAAWC,KAAKC,OAAO,CAACC,cAAciB;QAC5C,MAAMG,eAA0CzC,QAAQkB;QACxDwB,iCAAiCD,cAAc,GAAGxC;QAClD4B,aAAac,GAAG,CAACL;IACnB,EAAE,OAAOM,OAAO;QACd,IAAIC,eAAe,CAAC,qBAAqB,EAAEP,WAAW;QAEtD,IAAIZ,YAAY;YACdmB,gBAAgB,CAAC,wBAAwB,EAAEnB,YAAY;QACzD;QAEA,MAAMoB,QAAQ,IAAIC,MAAMF,cAAc;YAAED;QAAM;QAC9CE,MAAME,IAAI,GAAG;QACb,MAAMF;IACR;AACF;AAEA,SAASG,eAEPtB,SAAoB;IAEpB,MAAMW,YAAY,OAAOX,cAAc,WAAWA,YAAYA,UAAUR,IAAI;IAC5E,IAAI,CAACoB,KAAKD,YAAY;QACpB,gDAAgD;QAChD,0DAA0D;QAC1D,OAAOP;IACT;IAEA,IAAImB,QAAQf,WAAWgB,GAAG,CAACb;IAC3B,IAAIY,UAAUjB,WAAW;QACvB,IAAI;YACF,6DAA6D;YAC7D,MAAMf,WAAWC,KAAKC,OAAO,CAACC,cAAciB;YAC5C,8FAA8F;YAC9F,iGAAiG;YACjG,MAAMG,eAA0CzC,QAAQkB;YACxDwB,iCAAiCD,cAAc,GAAGxC;YAClDiD,QAAQhB;QACV,EAAE,OAAOU,OAAO;YACd,MAAMC,eAAe,CAAC,qBAAqB,EAAEP,UAAU,aAAa,EAAE,IAAI,CAACc,CAAC,CAACC,EAAE,EAAE;YACjF,MAAMP,QAAQ,IAAIC,MAAMF,cAAc;gBAAED;YAAM;YAC9CE,MAAME,IAAI,GAAG;YAEb,+EAA+E;YAC/EE,QAAQlB,QAAQsB,MAAM,CAACR;QACzB;QACAX,WAAWoB,GAAG,CAACjB,WAAWY;IAC5B;IACA,sGAAsG;IACtG,OAAOA;AACT;AACAM,iBAAiBC,CAAC,GAAGR;AAErB,SAASS,oBAEPC,QAAgB;IAEhB,MAAMC,QAAO7D,IAAI8D,aAAa,CAAC,IAAIC,IAAIH,UAAUtC;IACjD,OAAO4B,eAAec,IAAI,CAAC,IAAI,EAAEH;AACnC;AACAJ,iBAAiBQ,CAAC,GAAGN;AAErB,SAASO,gBACP3B,SAAoB,EACpB4B,WAAqC,EACrCC,OAA4B;IAE5B,MAAMjD,WAAWC,KAAKC,OAAO,CAACC,cAAciB;IAE5C,OAAO8B,+BAA+BlD,UAAUiD;AAClD;AACAX,iBAAiBa,CAAC,GAAGJ;AAErB,SAASK,sBACPhC,SAAoB,EACpB4B,WAAqC;IAErC,MAAMhD,WAAWC,KAAKC,OAAO,CAACC,cAAciB;IAE5C,OAAOiC,2BAA2BrD;AACpC;AACAsC,iBAAiBgB,CAAC,GAAGF;AAErB,SAASG,iBAAiBC,OAAoB;IAC5C,MAAM,IAAI3B,MAAM;AAClB;AAEAnD,qBAAqB+E,CAAC,GAAGF;AAEzB,SAASG,kBACPvB,EAAY,EACZwB,UAAsB,EACtBC,UAAsB;IAEtB,MAAMC,gBAAgB9E,gBAAgBkD,GAAG,CAACE;IAC1C,IAAI,OAAO0B,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,IAAIC;QACJ,OAAQH;YACN;gBACEG,sBAAsB,CAAC,4BAA4B,EAAEF,YAAY;gBACjE;YACF;gBACEE,sBAAsB,CAAC,oCAAoC,EAAEF,YAAY;gBACzE;YACF;gBACEG,UACEJ,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;QAE1D;QACA,MAAM,IAAI9B,MACR,CAAC,OAAO,EAAEM,GAAG,kBAAkB,EAAE2B,oBAAoB,0CAA0C,CAAC;IAEpG;IAEA,MAAME,UAAiBC,mBAAmB9B;IAC1C,MAAM+B,UAAUF,QAAOE,OAAO;IAC9BhF,WAAW,CAACiD,GAAG,GAAG6B;IAElB,MAAMG,UAAU,IAAKxF,QACnBqF,SACAE;IAEF,4EAA4E;IAC5E,IAAI;QACFL,cAAcM,SAASH,SAAQE;IACjC,EAAE,OAAOtC,OAAO;QACdoC,QAAOpC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEAoC,QAAOI,MAAM,GAAG;IAChB,IAAIJ,QAAOK,eAAe,IAAIL,QAAOE,OAAO,KAAKF,QAAOK,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWN,QAAOE,OAAO,EAAEF,QAAOK,eAAe;IACnD;IAEA,OAAOL;AACT;AAEA;;CAEC,GACD,aAAa;AACb,SAASO,iCACPpC,EAAY,EACZqC,YAAoB;IAEpB,MAAMR,UAAS9E,WAAW,CAACiD,GAAG;IAE9B,IAAI6B,SAAQ;QACV,IAAIA,QAAOpC,KAAK,EAAE;YAChB,MAAMoC,QAAOpC,KAAK;QACpB;QAEA,OAAOoC;IACT;IAEA,OAAON,kBAAkBvB,OAAuBqC,aAAarC,EAAE;AACjE;AAEA;;CAEC,GACD,SAASsC,yBACPrD,SAAoB,EACpB7B,QAAkB;IAElB,OAAOmE,kBAAkBnE,aAA8B6B;AACzD;AAEA;;CAEC,GACD,oFAAoF;AACpF,SAASsD,8BACPtD,SAAoB,EACpB7B,QAAkB;IAElB,MAAMyE,UAAS9E,WAAW,CAACK,SAAS;IACpC,IAAIyE,SAAQ;QACV,IAAIA,QAAOpC,KAAK,EAAE;YAChB,MAAMoC,QAAOpC,KAAK;QACpB;QACA,OAAOoC;IACT;IAEA,OAAOS,yBAAyBrD,WAAW7B;AAC7C;AAEA,MAAMoF,aAAa;AACnB;;CAEC,GACD,SAAStD,KAAKuD,cAAoC;IAChD,OAAOD,WAAWE,IAAI,CAACD;AACzB;AAEAE,OAAOZ,OAAO,GAAG,CAAC1D,aAA0B,CAAC;QAC3C0B,GAAG,CAACC,KAAiBuC,8BAA8BlE,YAAY2B;QAC/D9C,GAAG,CAACoB,YAAyBF,iBAAiBC,YAAYC;IAC5D,CAAC","ignoreList":[0]}}]
+    {"offset": {"line": 587, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/nodejs/runtime.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../shared/runtime-utils.ts\" />\n/// <reference path=\"../shared-node/base-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-externals-utils.ts\" />\n/// <reference path=\"../shared-node/node-wasm-utils.ts\" />\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n}\n\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext<Module> {\n  R: ResolvePathFromModule\n  x: ExternalRequire\n  y: ExternalImport\n}\n\nconst nodeContextPrototype = Context.prototype as TurbopackNodeBuildContext\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackNodeBuildContext\n) => unknown\n\nconst url = require('url') as typeof import('url')\n\nconst moduleFactories: ModuleFactories = new Map()\nnodeContextPrototype.M = moduleFactories\nconst moduleCache: ModuleCache<Module> = Object.create(null)\nnodeContextPrototype.c = moduleCache\n\n/**\n * Returns an absolute path to the given module's id.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  const exportedPath = exported?.default ?? exported\n  if (typeof exportedPath !== 'string') {\n    return exported as any\n  }\n\n  const strippedAssetPrefix = exportedPath.slice(ASSET_PREFIX.length)\n  const resolved = path.resolve(RUNTIME_ROOT, strippedAssetPrefix)\n\n  return url.pathToFileURL(resolved).href\n}\nnodeContextPrototype.R = resolvePathFromModule\n\nfunction loadRuntimeChunk(sourcePath: ChunkPath, chunkData: ChunkData): void {\n  if (typeof chunkData === 'string') {\n    loadRuntimeChunkPath(sourcePath, chunkData)\n  } else {\n    loadRuntimeChunkPath(sourcePath, chunkData.path)\n  }\n}\n\nconst loadedChunks = new Set<ChunkPath>()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise<void> = Promise.resolve(undefined)\nconst chunkCache = new Map<ChunkPath, Promise<void>>()\n\nfunction clearChunkCache() {\n  chunkCache.clear()\n}\n\nfunction loadRuntimeChunkPath(\n  sourcePath: ChunkPath,\n  chunkPath: ChunkPath\n): void {\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return\n  }\n\n  if (loadedChunks.has(chunkPath)) {\n    return\n  }\n\n  try {\n    const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n    const chunkModules: CompressedModuleFactories = require(resolved)\n    installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n    loadedChunks.add(chunkPath)\n  } catch (cause) {\n    let errorMessage = `Failed to load chunk ${chunkPath}`\n\n    if (sourcePath) {\n      errorMessage += ` from runtime for chunk ${sourcePath}`\n    }\n\n    const error = new Error(errorMessage, { cause })\n    error.name = 'ChunkLoadError'\n    throw error\n  }\n}\n\nfunction loadChunkAsync(\n  this: TurbopackBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  const chunkPath = typeof chunkData === 'string' ? chunkData : chunkData.path\n  if (!isJs(chunkPath)) {\n    // We only support loading JS chunks in Node.js.\n    // This branch can be hit when trying to load a CSS chunk.\n    return unsupportedLoadChunk\n  }\n\n  let entry = chunkCache.get(chunkPath)\n  if (entry === undefined) {\n    try {\n      // resolve to an absolute path to simplify `require` handling\n      const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n      // TODO: consider switching to `import()` to enable concurrent chunk loading and async file io\n      // However this is incompatible with hot reloading (since `import` doesn't use the require cache)\n      const chunkModules: CompressedModuleFactories = require(resolved)\n      installCompressedModuleFactories(chunkModules, 0, moduleFactories)\n      entry = loadedChunk\n    } catch (cause) {\n      const errorMessage = `Failed to load chunk ${chunkPath} from module ${this.m.id}`\n      const error = new Error(errorMessage, { cause })\n      error.name = 'ChunkLoadError'\n\n      // Cache the failure promise, future requests will also get this same rejection\n      entry = Promise.reject(error)\n    }\n    chunkCache.set(chunkPath, entry)\n  }\n  // TODO: Return an instrumented Promise that React can use instead of relying on referential equality.\n  return entry\n}\ncontextPrototype.l = loadChunkAsync\n\nfunction loadChunkAsyncByUrl(\n  this: TurbopackBaseContext<Module>,\n  chunkUrl: string\n) {\n  const path = url.fileURLToPath(new URL(chunkUrl, RUNTIME_ROOT)) as ChunkPath\n  return loadChunkAsync.call(this, path)\n}\ncontextPrototype.L = loadChunkAsyncByUrl\n\nfunction loadWebAssembly(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module,\n  imports: WebAssembly.Imports\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return instantiateWebAssemblyFromPath(resolved, imports)\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  chunkPath: ChunkPath,\n  _edgeModule: () => WebAssembly.Module\n) {\n  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)\n\n  return compileWebAssemblyFromPath(resolved)\n}\ncontextPrototype.u = loadWebAssemblyModule\n\nfunction getWorkerURL(\n  _entrypoint: ChunkPath,\n  _moduleChunks: ChunkPath[],\n  _shared: boolean\n): URL {\n  throw new Error('Worker urls are not implemented yet for Node.js')\n}\n\nnodeContextPrototype.b = getWorkerURL\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    let instantiationReason: string\n    switch (sourceType) {\n      case SourceType.Runtime:\n        instantiationReason = `as a runtime entry of chunk ${sourceData}`\n        break\n      case SourceType.Parent:\n        instantiationReason = `because it was required from module ${sourceData}`\n        break\n      default:\n        invariant(\n          sourceType,\n          (sourceType) => `Unknown source type: ${sourceType}`\n        )\n    }\n    throw new Error(\n      `Module ${id} was instantiated ${instantiationReason}, but the module factory is not available.`\n    )\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n  moduleCache[id] = module\n\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  module.loaded = true\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore\nfunction getOrInstantiateModuleFromParent(\n  id: ModuleId,\n  sourceModule: Module\n): Module {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it as a runtime module if it is not cached.\n */\n// @ts-ignore TypeScript doesn't separate this module space from the browser runtime\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateRuntimeModule(chunkPath, moduleId)\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nmodule.exports = (sourcePath: ChunkPath) => ({\n  m: (id: ModuleId) => getOrInstantiateRuntimeModule(sourcePath, id),\n  c: (chunkData: ChunkData) => loadRuntimeChunk(sourcePath, chunkData),\n})\n"],"names":["SourceType","process","env","TURBOPACK","nodeContextPrototype","Context","prototype","url","require","moduleFactories","Map","M","moduleCache","Object","create","c","resolvePathFromModule","moduleId","exported","r","exportedPath","default","strippedAssetPrefix","slice","ASSET_PREFIX","length","resolved","path","resolve","RUNTIME_ROOT","pathToFileURL","href","R","loadRuntimeChunk","sourcePath","chunkData","loadRuntimeChunkPath","loadedChunks","Set","unsupportedLoadChunk","Promise","undefined","loadedChunk","chunkCache","clearChunkCache","clear","chunkPath","isJs","has","chunkModules","installCompressedModuleFactories","add","cause","errorMessage","error","Error","name","loadChunkAsync","entry","get","m","id","reject","set","contextPrototype","l","loadChunkAsyncByUrl","chunkUrl","path1","fileURLToPath","URL","call","L","loadWebAssembly","_edgeModule","imports","instantiateWebAssemblyFromPath","w","loadWebAssemblyModule","compileWebAssemblyFromPath","u","getWorkerURL","_entrypoint","_moduleChunks","_shared","b","instantiateModule","sourceType","sourceData","moduleFactory","instantiationReason","invariant","module1","createModuleObject","exports","context","loaded","namespaceObject","interopEsm","getOrInstantiateModuleFromParent","sourceModule","instantiateRuntimeModule","getOrInstantiateRuntimeModule","regexJsUrl","chunkUrlOrPath","test","module"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/5c1d0_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/5c1d0_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js
index 7e8ba39e20fa77..47dd092ecababb 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/5c1d0_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/5c1d0_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js
@@ -520,7 +520,7 @@ function applyModuleFactoryName(factory) {
  * shared runtime utils.
  */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
 /// <reference path="../../../shared/runtime-utils.ts" />
-// Used in WebWorkers to tell the runtime about the chunk base path
+// Used in WebWorkers to tell the runtime about the chunk suffix
 const browserContextPrototype = Context.prototype;
 var SourceType = /*#__PURE__*/ function(SourceType) {
     /**
@@ -683,24 +683,29 @@ browserContextPrototype.R = resolvePathFromModule;
 }
 browserContextPrototype.P = resolveAbsolutePath;
 /**
- * Returns a blob URL for the worker.
- * @param chunks list of chunks to load
- */ function getWorkerBlobURL(chunks) {
-    // It is important to reverse the array so when bootstrapping we can infer what chunk is being
-    // evaluated by poping urls off of this array.  See `getPathFromScript`
-    let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};
-self.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};
-self.NEXT_DEPLOYMENT_ID = ${JSON.stringify(globalThis.NEXT_DEPLOYMENT_ID)};
-self.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};
-importScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`;
-    let blob = new Blob([
-        bootstrap
-    ], {
-        type: 'text/javascript'
-    });
-    return URL.createObjectURL(blob);
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    const url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    const params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map((chunk)=>getChunkRelativeUrl(chunk))
+    };
+    const paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
 }
-browserContextPrototype.b = getWorkerBlobURL;
+browserContextPrototype.b = getWorkerURL;
 /**
  * Instantiates a runtime module.
  */ function instantiateRuntimeModule(moduleId, chunkPath) {
@@ -1698,7 +1703,7 @@ let BACKEND;
             // ignore
             } else if (isJs(chunkUrl)) {
                 self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
-                importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl);
+                importScripts(chunkUrl);
             } else {
                 throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
             }
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/780ce_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/780ce_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js.map
index 3c9e1b4f4ec555..2092500cff64fb 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/780ce_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_dev_runtime/output/780ce_turbopack-tests_tests_snapshot_runtime_default_dev_runtime_input_index_c0f7e0b0.js.map
@@ -3,8 +3,8 @@
   "sources": [],
   "sections": [
     {"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","err","asyncModule","body","hasAwait","depQueues","Set","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 514, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk base path\ndeclare var TURBOPACK_WORKER_LOCATION: string\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it can't be detected via document.currentScript\n// Note it's stored in reversed order to use push and pop\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a blob URL for the worker.\n * @param chunks list of chunks to load\n */\nfunction getWorkerBlobURL(chunks: ChunkPath[]): string {\n  // It is important to reverse the array so when bootstrapping we can infer what chunk is being\n  // evaluated by poping urls off of this array.  See `getPathFromScript`\n  let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};\nself.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};\nself.NEXT_DEPLOYMENT_ID = ${JSON.stringify((globalThis as any).NEXT_DEPLOYMENT_ID)};\nself.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};\nimportScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`\n  let blob = new Blob([bootstrap], { type: 'text/javascript' })\n  return URL.createObjectURL(blob)\n}\nbrowserContextPrototype.b = getWorkerBlobURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerBlobURL","chunks","bootstrap","JSON","stringify","location","origin","CHUNK_SUFFIX","globalThis","NEXT_DEPLOYMENT_ID","reverse","blob","Blob","type","URL","createObjectURL","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","encodeURIComponent","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 742, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1596, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","TURBOPACK_WORKER_LOCATION","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1761, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 514, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 747, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1766, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/5c1d0_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js b/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/5c1d0_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js
index 878b65ab3bf98a..906ba9a7199062 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/5c1d0_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/5c1d0_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js
@@ -768,7 +768,7 @@ function applyModuleFactoryName(factory) {
  * shared runtime utils.
  */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
 /// <reference path="../../../shared/runtime-utils.ts" />
-// Used in WebWorkers to tell the runtime about the chunk base path
+// Used in WebWorkers to tell the runtime about the chunk suffix
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -1181,24 +1181,31 @@ browserContextPrototype.R = resolvePathFromModule;
 }
 browserContextPrototype.P = resolveAbsolutePath;
 /**
- * Returns a blob URL for the worker.
- * @param chunks list of chunks to load
- */ function getWorkerBlobURL(chunks) {
-    // It is important to reverse the array so when bootstrapping we can infer what chunk is being
-    // evaluated by poping urls off of this array.  See `getPathFromScript`
-    var bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};
-self.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};
-self.NEXT_DEPLOYMENT_ID = ${JSON.stringify(globalThis.NEXT_DEPLOYMENT_ID)};
-self.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};
-importScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`;
-    var blob = new Blob([
-        bootstrap
-    ], {
-        type: 'text/javascript'
-    });
-    return URL.createObjectURL(blob);
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    var url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    var params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map(function(chunk) {
+            return getChunkRelativeUrl(chunk);
+        })
+    };
+    var paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
 }
-browserContextPrototype.b = getWorkerBlobURL;
+browserContextPrototype.b = getWorkerURL;
 /**
  * Instantiates a runtime module.
  */ function instantiateRuntimeModule(moduleId, chunkPath) {
@@ -1631,7 +1638,7 @@ var BACKEND;
             // ignore
             } else if (isJs(chunkUrl)) {
                 self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
-                importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl);
+                importScripts(chunkUrl);
             } else {
                 throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
             }
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/780ce_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/780ce_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js.map
index 43e49415a05386..1e002b14541a46 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/780ce_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/swc_transforms/preset_env/output/780ce_turbopack-tests_tests_snapshot_swc_transforms_preset_env_input_index_5aaf1327.js.map
@@ -3,7 +3,7 @@
   "sources": [],
   "sections": [
     {"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","_iteratorError","ownKeys","keys","_iteratorError1","key","includes","push","dynamicExport","object","_type_of","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","_key","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","_obj","err","_obj1","asyncModule","body","hasAwait","depQueues","Set","_createPromise","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","key1","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"AAAA;;;;;CAKC,GAED,oDAAoD,GAEpD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAU7C,IAAMA,qBAAqB,IAAIC;AAE/B;;CAEC,GACD,SAASC,QAEPC,MAAc,EACdC,OAAgB;IAEhB,IAAI,CAACC,CAAC,GAAGF;IACT,gFAAgF;IAChF,yEAAyE;IACzE,+CAA+C;IAC/C,8EAA8E;IAC9E,sEAAsE;IACtE,iBAAiB;IACjB,4FAA4F;IAC5F,IAAI,CAACG,CAAC,GAAGF;AACX;AACA,IAAMG,mBAAmBL,QAAQM,SAAS;AA+B1C,IAAMC,iBAAiBC,OAAOF,SAAS,CAACC,cAAc;AACtD,IAAME,cAAc,OAAOC,WAAW,eAAeA,OAAOD,WAAW;AAEvE,SAASE,WACPC,GAAQ,EACRC,IAAiB,EACjBC,OAA2C;IAE3C,IAAI,CAACP,eAAeQ,IAAI,CAACH,KAAKC,OAAOL,OAAOQ,cAAc,CAACJ,KAAKC,MAAMC;AACxE;AAEA,SAASG,qBACPC,WAAgC,EAChCC,EAAY;IAEZ,IAAIlB,SAASiB,WAAW,CAACC,GAAG;IAC5B,IAAI,CAAClB,QAAQ;QACX,0FAA0F;QAC1F,4DAA4D;QAC5DA,SAASmB,mBAAmBD;QAC5BD,WAAW,CAACC,GAAG,GAAGlB;IACpB;IACA,OAAOA;AACT;AAEA;;CAEC,GACD,SAASmB,mBAAmBD,EAAY;IACtC,OAAO;QACLjB,SAAS,CAAC;QACVmB,OAAOC;QACPH,IAAAA;QACAI,iBAAiBD;IACnB;AACF;AAGA,IAAME,mBAAmB;AAUzB;;CAEC,GACD,SAASC,IAAIvB,OAAgB,EAAEwB,QAAqB;IAClDf,WAAWT,SAAS,cAAc;QAAEyB,OAAO;IAAK;IAChD,IAAIlB,aAAaE,WAAWT,SAASO,aAAa;QAAEkB,OAAO;IAAS;IACpE,IAAIC,IAAI;IACR,MAAOA,IAAIF,SAASG,MAAM,CAAE;QAC1B,IAAMC,WAAWJ,QAAQ,CAACE,IAAI;QAC9B,IAAMG,gBAAgBL,QAAQ,CAACE,IAAI;QACnC,IAAI,OAAOG,kBAAkB,UAAU;YACrC,IAAIA,kBAAkBP,kBAAkB;gBACtCb,WAAWT,SAAS4B,UAAU;oBAC5BH,OAAOD,QAAQ,CAACE,IAAI;oBACpBI,YAAY;oBACZC,UAAU;gBACZ;YACF,OAAO;gBACL,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEH,eAAe;YACpD;QACF,OAAO;YACL,IAAMI,WAAWJ;YACjB,IAAI,OAAOL,QAAQ,CAACE,EAAE,KAAK,YAAY;gBACrC,IAAMQ,WAAWV,QAAQ,CAACE,IAAI;gBAC9BjB,WAAWT,SAAS4B,UAAU;oBAC5BO,KAAKF;oBACLG,KAAKF;oBACLJ,YAAY;gBACd;YACF,OAAO;gBACLrB,WAAWT,SAAS4B,UAAU;oBAC5BO,KAAKF;oBACLH,YAAY;gBACd;YACF;QACF;IACF;IACAxB,OAAO+B,IAAI,CAACrC;AACd;AAEA;;CAEC,GACD,SAASsC,UAEPd,QAAqB,EACrBP,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACAH,OAAOsB,eAAe,GAAGrB;IACzBuB,IAAIvB,SAASwB;AACf;AACArB,iBAAiBqC,CAAC,GAAGF;AAGrB,SAASG,qBACP1C,MAAc,EACdC,OAAgB;IAEhB,IAAI0C,oBACF9C,mBAAmBuC,GAAG,CAACpC;IAEzB,IAAI,CAAC2C,mBAAmB;QACtB9C,mBAAmBwC,GAAG,CAACrC,QAAS2C,oBAAoB,EAAE;QACtD3C,OAAOC,OAAO,GAAGD,OAAOsB,eAAe,GAAG,IAAIsB,MAAM3C,SAAS;YAC3DmC,KAAAA,SAAAA,IAAIS,MAAM,EAAEC,IAAI;gBACd,IACExC,eAAeQ,IAAI,CAAC+B,QAAQC,SAC5BA,SAAS,aACTA,SAAS,cACT;oBACA,OAAOC,QAAQX,GAAG,CAACS,QAAQC;gBAC7B;oBACKE,kCAAAA,2BAAAA;;oBAAL,QAAKA,YAAaL,sCAAbK,SAAAA,6BAAAA,QAAAA,yBAAAA,iCAAiC;wBAAjCA,IAAMrC,MAANqC;wBACH,IAAMtB,QAAQqB,QAAQX,GAAG,CAACzB,KAAKmC;wBAC/B,IAAIpB,UAAUL,WAAW,OAAOK;oBAClC;;oBAHKsB;oBAAAA;;;6BAAAA,6BAAAA;4BAAAA;;;4BAAAA;kCAAAA;;;;gBAIL,OAAO3B;YACT;YACA4B,SAAAA,SAAAA,QAAQJ,MAAM;gBACZ,IAAMK,OAAOH,QAAQE,OAAO,CAACJ;oBACxBG,kCAAAA,2BAAAA;;oBAAL,QAAKA,YAAaL,sCAAbK,SAAAA,6BAAAA,QAAAA,yBAAAA,iCAAiC;wBAAjCA,IAAMrC,MAANqC;4BACEG,mCAAAA,4BAAAA;;4BAAL,QAAKA,aAAaJ,QAAQE,OAAO,CAACtC,yBAA7BwC,UAAAA,8BAAAA,SAAAA,0BAAAA,kCAAmC;gCAAnCA,IAAMC,MAAND;gCACH,IAAIC,QAAQ,aAAa,CAACF,KAAKG,QAAQ,CAACD,MAAMF,KAAKI,IAAI,CAACF;4BAC1D;;4BAFKD;4BAAAA;;;qCAAAA,8BAAAA;oCAAAA;;;oCAAAA;0CAAAA;;;;oBAGP;;oBAJKH;oBAAAA;;;6BAAAA,6BAAAA;4BAAAA;;;4BAAAA;kCAAAA;;;;gBAKL,OAAOE;YACT;QACF;IACF;IACA,OAAOP;AACT;AAEA;;CAEC,GACD,SAASY,cAEPC,MAA2B,EAC3BtC,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACA,IAAMwC,oBAAoBD,qBAAqB1C,QAAQC;IAEvD,IAAIwD,CAAAA,OAAOD,uCAAPC,SAAOD,OAAK,MAAM,YAAYA,WAAW,MAAM;QACjDb,kBAAkBW,IAAI,CAACE;IACzB;AACF;AACApD,iBAAiBsD,CAAC,GAAGH;AAErB,SAASI,YAEPjC,KAAU,EACVR,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGyB;AACnB;AACAtB,iBAAiBwD,CAAC,GAAGD;AAErB,SAASE,gBAEPC,SAAc,EACd5C,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGD,OAAOsB,eAAe,GAAGwC;AAC5C;AACA1D,iBAAiB2D,CAAC,GAAGF;AAErB,SAASG,aAAarD,GAAiC,EAAEyC,GAAoB;IAC3E,OAAO;eAAMzC,GAAG,CAACyC,IAAI;;AACvB;AAEA;;CAEC,GACD,IAAMa,WAA8B1D,OAAO2D,cAAc,GACrD,SAACvD;WAAQJ,OAAO2D,cAAc,CAACvD;IAC/B,SAACA;WAAQA,IAAIwD,SAAS;;AAE1B,iDAAiD,GACjD,IAAMC,kBAAkB;IAAC;IAAMH,SAAS,CAAC;IAAIA,SAAS,EAAE;IAAGA,SAASA;CAAU;AAE9E;;;;;;CAMC,GACD,SAASI,WACPC,GAAY,EACZC,EAAsB,EACtBC,kBAA4B;IAE5B,IAAM/C,WAAwB,EAAE;IAChC,IAAIgD,kBAAkB,CAAC;IACvB,IACE,IAAIC,UAAUJ,KACd,CAACb,CAAAA,OAAOiB,wCAAPjB,SAAOiB,QAAM,MAAM,YAAY,OAAOA,YAAY,UAAU,KAC7D,CAACN,gBAAgBf,QAAQ,CAACqB,UAC1BA,UAAUT,SAASS,SACnB;YACK1B,kCAAAA,2BAAAA;;YAAL,QAAKA,YAAazC,OAAOoE,mBAAmB,CAACD,6BAAxC1B,SAAAA,6BAAAA,QAAAA,yBAAAA,iCAAkD;gBAAlDA,IAAMI,MAANJ;gBACHvB,SAAS6B,IAAI,CAACF,KAAKY,aAAaM,KAAKlB;gBACrC,IAAIqB,oBAAoB,CAAC,KAAKrB,QAAQ,WAAW;oBAC/CqB,kBAAkBhD,SAASG,MAAM,GAAG;gBACtC;YACF;;YALKoB;YAAAA;;;qBAAAA,6BAAAA;oBAAAA;;;oBAAAA;0BAAAA;;;;IAMP;IAEA,6BAA6B;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,CAACwB,sBAAsBC,mBAAmB,CAAC,GAAG;QACjD,8FAA8F;QAC9F,IAAIA,mBAAmB,GAAG;YACxB,oCAAoC;YACpChD,SAASmD,MAAM,CAACH,iBAAiB,GAAGlD,kBAAkB+C;QACxD,OAAO;YACL7C,SAAS6B,IAAI,CAAC,WAAW/B,kBAAkB+C;QAC7C;IACF;IAEA9C,IAAI+C,IAAI9C;IACR,OAAO8C;AACT;AAEA,SAASM,SAASP,GAAsB;IACtC,IAAI,OAAOA,QAAQ,YAAY;QAC7B,OAAO;YAAqBQ,IAAAA,IAAAA,OAAAA,UAAAA,QAAAA,AAAGC,OAAHD,UAAAA,OAAAA,OAAAA,GAAAA,OAAAA,MAAAA;gBAAGC,KAAHD,QAAAA,SAAAA,CAAAA,KAAc;;YACxC,OAAOR,IAAIU,KAAK,CAAC,IAAI,EAAED;QACzB;IACF,OAAO;QACL,OAAOxE,OAAO0E,MAAM,CAAC;IACvB;AACF;AAEA,SAASC,UAEPhE,EAAY;IAEZ,IAAMlB,SAASmF,iCAAiCjE,IAAI,IAAI,CAAChB,CAAC;IAE1D,8DAA8D;IAC9D,IAAIF,OAAOsB,eAAe,EAAE,OAAOtB,OAAOsB,eAAe;IAEzD,iGAAiG;IACjG,IAAMgD,MAAMtE,OAAOC,OAAO;IAC1B,OAAQD,OAAOsB,eAAe,GAAG+C,WAC/BC,KACAO,SAASP,MACTA,OAAO,AAACA,IAAYc,UAAU;AAElC;AACAhF,iBAAiBuB,CAAC,GAAGuD;AAErB,SAASG,YAEPC,QAAkB;IAElB,IAAMC,SAAS,IAAI,CAACC,CAAC,CAACF;IAGtB,OAAOC,OAAOL,UAAUO,IAAI,CAAC,IAAI;AACnC;AACArF,iBAAiBsF,CAAC,GAAGL;AAErB,+EAA+E;AAC/E,6EAA6E;AAC7E,IAAMM,iBACJ,aAAa;AACb,OAAOC,YAAY,aAEfA,UACA,SAASC;IACP,MAAM,IAAI5D,MAAM;AAClB;AACN7B,iBAAiB0F,CAAC,GAAGH;AAErB,SAASI,gBAEP7E,EAAY;IAEZ,OAAOiE,iCAAiCjE,IAAI,IAAI,CAAChB,CAAC,EAAED,OAAO;AAC7D;AACAG,iBAAiBoF,CAAC,GAAGO;AAErB;;;;;;CAMC,GACD,SAASC,aAAaC,OAAe;IACnC,wFAAwF;IACxF,4DAA4D;IAC5D,IAAMC,YAAYD,QAAQE,OAAO,CAAC;IAClC,IAAID,cAAc,CAAC,GAAG;QACpBD,UAAUA,QAAQG,SAAS,CAAC,GAAGF;IACjC;IAEA,IAAMG,aAAaJ,QAAQE,OAAO,CAAC;IACnC,IAAIE,eAAe,CAAC,GAAG;QACrBJ,UAAUA,QAAQG,SAAS,CAAC,GAAGC;IACjC;IAEA,OAAOJ;AACT;AACA;;CAEC,GACD,SAASK,cAAcC,GAAqB;IAC1C,SAASD,cAAcpF,EAAU;QAC/BA,KAAK8E,aAAa9E;QAClB,IAAIZ,eAAeQ,IAAI,CAACyF,KAAKrF,KAAK;YAChC,OAAOqF,GAAG,CAACrF,GAAG,CAAClB,MAAM;QACvB;QAEA,IAAMG,IAAI,IAAI8B,MAAM,CAAC,oBAAoB,EAAEf,GAAG,CAAC,CAAC;QAC9Cf,EAAUqG,IAAI,GAAG;QACnB,MAAMrG;IACR;IAEAmG,cAAcpD,IAAI,GAAG;QACnB,OAAO3C,OAAO2C,IAAI,CAACqD;IACrB;IAEAD,cAAcG,OAAO,GAAG,SAACvF;QACvBA,KAAK8E,aAAa9E;QAClB,IAAIZ,eAAeQ,IAAI,CAACyF,KAAKrF,KAAK;YAChC,OAAOqF,GAAG,CAACrF,GAAG,CAACA,EAAE;QACnB;QAEA,IAAMf,IAAI,IAAI8B,MAAM,CAAC,oBAAoB,EAAEf,GAAG,CAAC,CAAC;QAC9Cf,EAAUqG,IAAI,GAAG;QACnB,MAAMrG;IACR;IAEAmG,cAAcI,MAAM,GAAG,SAAOxF;;;;;wBACrB;;4BAAOoF,cAAcpF;;;wBAA5B;;4BAAO;;;;QACT;;IAEA,OAAOoF;AACT;AACAlG,iBAAiBuG,CAAC,GAAGL;AAErB;;CAEC,GACD,SAASM,aAAaC,SAAoB;IACxC,OAAO,OAAOA,cAAc,WAAWA,YAAYA,UAAUC,IAAI;AACnE;AAEA,SAASC,UAAmBC,YAAiB;IAC3C,OACEA,gBAAgB,QAChBvD,CAAAA,OAAOuD,6CAAPvD,SAAOuD,aAAW,MAAM,YACxB,UAAUA,gBACV,OAAOA,aAAaC,IAAI,KAAK;AAEjC;AAEA,SAASC,iBAA+BvG,GAAM;IAC5C,OAAOwG,mBAAmBxG;AAC5B;AAEA,SAASyG;IACP,IAAIX;IACJ,IAAIY;IAEJ,IAAMC,UAAU,IAAIC,QAAW,SAACC,KAAKC;QACnCJ,SAASI;QACThB,UAAUe;IACZ;IAEA,OAAO;QACLF,SAAAA;QACAb,SAASA;QACTY,QAAQA;IACV;AACF;AAEA,gFAAgF;AAChF,0CAA0C;AAC1C,yBAAyB;AACzB,8BAA8B;AAC9B,6EAA6E;AAC7E,wEAAwE;AACxE,SAASK,iCACPC,YAAuC,EACvCC,MAAc,EACdC,eAAgC,EAChCC,WAAoC;IAEpC,IAAInG,IAAIiG;IACR,MAAOjG,IAAIgG,aAAa/F,MAAM,CAAE;QAC9B,IAAI0D,WAAWqC,YAAY,CAAChG,EAAE;QAC9B,IAAIoG,MAAMpG,IAAI;QACd,4BAA4B;QAC5B,MACEoG,MAAMJ,aAAa/F,MAAM,IACzB,OAAO+F,YAAY,CAACI,IAAI,KAAK,WAC7B;YACAA;QACF;QACA,IAAIA,QAAQJ,aAAa/F,MAAM,EAAE;YAC/B,MAAM,IAAIK,MAAM;QAClB;QACA,+FAA+F;QAC/F,sFAAsF;QACtF,IAAI,CAAC4F,gBAAgBG,GAAG,CAAC1C,WAAW;YAClC,IAAM2C,kBAAkBN,YAAY,CAACI,IAAI;YACzCG,uBAAuBD;YACvBH,wBAAAA,kCAAAA,YAAcxC;YACd,MAAO3D,IAAIoG,KAAKpG,IAAK;gBACnB2D,WAAWqC,YAAY,CAAChG,EAAE;gBAC1BkG,gBAAgBxF,GAAG,CAACiD,UAAU2C;YAChC;QACF;QACAtG,IAAIoG,MAAM,GAAE,sFAAsF;IACpG;AACF;AAEA,2CAA2C;AAC3C,+HAA+H;AAE/H,IAAMZ,kBAAkB1G,OAAO;AAC/B,IAAM0H,mBAAmB1H,OAAO;AAChC,IAAM2H,iBAAiB3H,OAAO;AAa9B,SAAS4H,aAAaC,KAAkB;IACtC,IAAIA,SAASA,MAAMC,MAAM,QAA2B;QAClDD,MAAMC,MAAM;QACZD,MAAME,OAAO,CAAC,SAACC;mBAAOA,GAAGC,UAAU;;QACnCJ,MAAME,OAAO,CAAC,SAACC;mBAAQA,GAAGC,UAAU,KAAKD,GAAGC,UAAU,KAAKD;;IAC7D;AACF;AAYA,SAASE,SAASC,IAAW;IAC3B,OAAOA,KAAKrC,GAAG,CAAC,SAACsC;QACf,IAAIA,QAAQ,QAAQpF,CAAAA,OAAOoF,oCAAPpF,SAAOoF,IAAE,MAAM,UAAU;YAC3C,IAAI3B,iBAAiB2B,MAAM,OAAOA;YAClC,IAAI9B,UAAU8B,MAAM;gBAClB,IAAMP,QAAoB/H,OAAOuI,MAAM,CAAC,EAAE,EAAE;oBAC1CP,MAAM;gBACR;oBAE4BQ;gBAA5B,IAAMpI,OAAsBoI,WAC1B,iBAD0BA,MACzBZ,kBAAmB,CAAC,IACrB,iBAF0BY,MAEzB5B,iBAAkB,SAACsB;2BAAoCA,GAAGH;oBAFjCS;gBAK5BF,IAAI5B,IAAI,CACN,SAACO;oBACC7G,GAAG,CAACwH,iBAAiB,GAAGX;oBACxBa,aAAaC;gBACf,GACA,SAACU;oBACCrI,GAAG,CAACyH,eAAe,GAAGY;oBACtBX,aAAaC;gBACf;gBAGF,OAAO3H;YACT;QACF;YAEOsI;QAAP,OAAOA,YACL,iBADKA,OACJd,kBAAmBU,MACpB,iBAFKI,OAEJ9B,iBAAkB,YAAO,IAFrB8B;IAIT;AACF;AAEA,SAASC,YAEPC,IAKS,EACTC,QAAiB;IAEjB,IAAMpJ,SAAS,IAAI,CAACE,CAAC;IACrB,IAAMoI,QAAgCc,WAClC7I,OAAOuI,MAAM,CAAC,EAAE,EAAE;QAAEP,MAAM;IAAsB,KAChDlH;IAEJ,IAAMgI,YAA6B,IAAIC;IAEvC,IAAiDC,iBAAAA,iBAAzC9C,UAAyC8C,eAAzC9C,SAASY,SAAgCkC,eAAhClC,QAAQC,AAASkC,aAAeD,eAAxBjC;QAEqCyB;IAA9D,IAAMzB,UAA8B/G,OAAOuI,MAAM,CAACU,aAAYT,WAC5D,iBAD4DA,MAC3DZ,kBAAmBnI,OAAOC,OAAO,GAClC,iBAF4D8I,MAE3D5B,iBAAkB,SAACsB;QAClBH,SAASG,GAAGH;QACZe,UAAUb,OAAO,CAACC;QAClBnB,OAAO,CAAC,QAAQ,CAAC,YAAO;IAC1B,IAN4DyB;IAS9D,IAAMU,aAAiC;QACrCrH,KAAAA,SAAAA;YACE,OAAOkF;QACT;QACAjF,KAAAA,SAAAA,IAAIuB,CAAM;YACR,qCAAqC;YACrC,IAAIA,MAAM0D,SAAS;gBACjBA,OAAO,CAACa,iBAAiB,GAAGvE;YAC9B;QACF;IACF;IAEArD,OAAOQ,cAAc,CAACf,QAAQ,WAAWyJ;IACzClJ,OAAOQ,cAAc,CAACf,QAAQ,mBAAmByJ;IAEjD,SAASC,wBAAwBd,IAAW;QAC1C,IAAMe,cAAchB,SAASC;QAE7B,IAAMgB,YAAY;mBAChBD,YAAYpD,GAAG,CAAC,SAACsD;gBACf,IAAIA,CAAC,CAACzB,eAAe,EAAE,MAAMyB,CAAC,CAACzB,eAAe;gBAC9C,OAAOyB,CAAC,CAAC1B,iBAAiB;YAC5B;;QAEF,IAA6BoB,iBAAAA,iBAArBjC,UAAqBiC,eAArBjC,SAASb,UAAY8C,eAAZ9C;QAEjB,IAAMgC,KAAmBlI,OAAOuI,MAAM,CAAC;mBAAMrC,QAAQmD;WAAY;YAC/DlB,YAAY;QACd;QAEA,SAASoB,QAAQC,CAAa;YAC5B,IAAIA,MAAMzB,SAAS,CAACe,UAAUrB,GAAG,CAAC+B,IAAI;gBACpCV,UAAUW,GAAG,CAACD;gBACd,IAAIA,KAAKA,EAAExB,MAAM,QAA6B;oBAC5CE,GAAGC,UAAU;oBACbqB,EAAEzG,IAAI,CAACmF;gBACT;YACF;QACF;QAEAkB,YAAYpD,GAAG,CAAC,SAACsC;mBAAQA,GAAG,CAAC1B,gBAAgB,CAAC2C;;QAE9C,OAAOrB,GAAGC,UAAU,GAAGpB,UAAUsC;IACnC;IAEA,SAASK,YAAYjB,GAAS;QAC5B,IAAIA,KAAK;YACP3B,OAAQC,OAAO,CAACc,eAAe,GAAGY;QACpC,OAAO;YACLvC,QAAQa,OAAO,CAACa,iBAAiB;QACnC;QAEAE,aAAaC;IACf;IAEAa,KAAKO,yBAAyBO;IAE9B,IAAI3B,SAASA,MAAMC,MAAM,SAA0B;QACjDD,MAAMC,MAAM;IACd;AACF;AACAnI,iBAAiB8J,CAAC,GAAGhB;AAErB;;;;;;;;;CASC,GACD,IAAMiB,cAAc,SAASA,YAAuBC,QAAgB;IAClE,IAAMC,UAAU,IAAIC,IAAIF,UAAU;IAClC,IAAMG,SAA8B,CAAC;IACrC,IAAK,IAAMnH,OAAOiH,QAASE,MAAM,CAACnH,IAAI,GAAG,AAACiH,OAAe,CAACjH,IAAI;IAC9DmH,OAAOC,IAAI,GAAGJ;IACdG,OAAOE,QAAQ,GAAGL,SAASM,OAAO,CAAC,UAAU;IAC7CH,OAAOI,MAAM,GAAGJ,OAAOK,QAAQ,GAAG;IAClCL,OAAOM,QAAQ,GAAGN,OAAOO,MAAM,GAAG;yCAAIC;YAAAA;;eAAsBX;;IAC5D,IAAK,IAAMY,QAAOT,OAChBhK,OAAOQ,cAAc,CAAC,IAAI,EAAEiK,MAAK;QAC/BjJ,YAAY;QACZkJ,cAAc;QACdvJ,OAAO6I,MAAM,CAACS,KAAI;IACpB;AACJ;AACAb,YAAY9J,SAAS,GAAGiK,IAAIjK,SAAS;AACrCD,iBAAiB8K,CAAC,GAAGf;AAErB;;CAEC,GACD,SAASgB,UAAUC,KAAY,EAAEC,cAAoC;IACnE,MAAM,IAAIpJ,MAAM,CAAC,WAAW,EAAEoJ,eAAeD,QAAQ;AACvD;AAEA;;CAEC,GACD,SAASE,YAAYC,SAAmB;IACtC,MAAM,IAAItJ,MAAM;AAClB;AACA7B,iBAAiBoL,CAAC,GAAGF;AAErB,kGAAkG;AAClGlL,iBAAiBqL,CAAC,GAAGC;AAMrB,SAASxD,uBAAuByD,OAAiB;IAC/C,+DAA+D;IAC/DpL,OAAOQ,cAAc,CAAC4K,SAAS,QAAQ;QACrCjK,OAAO;IACT;AACF","ignoreList":[0]}},
-    {"offset": {"line": 762, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk base path\ndeclare var TURBOPACK_WORKER_LOCATION: string\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it can't be detected via document.currentScript\n// Note it's stored in reversed order to use push and pop\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a blob URL for the worker.\n * @param chunks list of chunks to load\n */\nfunction getWorkerBlobURL(chunks: ChunkPath[]): string {\n  // It is important to reverse the array so when bootstrapping we can infer what chunk is being\n  // evaluated by poping urls off of this array.  See `getPathFromScript`\n  let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};\nself.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};\nself.NEXT_DEPLOYMENT_ID = ${JSON.stringify((globalThis as any).NEXT_DEPLOYMENT_ID)};\nself.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};\nimportScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`\n  let blob = new Blob([bootstrap], { type: 'text/javascript' })\n  return URL.createObjectURL(blob)\n}\nbrowserContextPrototype.b = getWorkerBlobURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","includedList","modulesPromises","includedModuleChunksList","moduleChunksPromises","promise","moduleChunksToLoad","_iteratorError","moduleChunk","_iteratorError1","moduleChunkToLoad","promise1","_iteratorError2","includedModuleChunk","_iteratorError3","included","loadChunkPath","map","has","get","length","every","p","Promise","all","moduleChunks","filter","Set","add","set","push","path","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerBlobURL","chunks","bootstrap","JSON","stringify","location","origin","CHUNK_SUFFIX","globalThis","NEXT_DEPLOYMENT_ID","reverse","blob","Blob","type","URL","createObjectURL","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","encodeURIComponent","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
-    {"offset": {"line": 1242, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","getPathFromScript","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,IAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,IAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,IAAMO,mCAEF,SAACC,IAAIC;IACP,IAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,IAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,IAAMV,SAAiBgB,mBAAmBV;IAC1C,IAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,IAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,IAAMzB,YAAY0B,kBAAkBD,YAAY,CAAC,EAAE;IACnD,IAAIE;IACJ,8GAA8G;IAC9G,IAAIF,aAAaG,MAAM,KAAK,GAAG;QAC7BD,gBAAgBF,YAAY,CAAC,EAAE;IACjC,OAAO;QACLE,gBAAgBE;QAChBC,iCACEL,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOiB,QAAQP,aAAa,CAACxB,WAAW2B;AAC1C","ignoreList":[0]}},
-    {"offset": {"line": 1313, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","_self_TURBOPACK_CHUNK_SUFFIX","_document_currentScript_getAttribute","TURBOPACK_CHUNK_SUFFIX","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","resolver","_iteratorError","otherChunkData","otherChunkPath","otherChunkUrl","_iteratorError1","moduleId","getChunkRelativeUrl","getOrCreateResolver","resolve","otherChunks","getChunkPath","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","instance","fetchWebAssembly","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","self","TURBOPACK_NEXT_CHUNK_URLS","push","TURBOPACK_WORKER_LOCATION","Error","decodedChunkUrl","decodeURI","previousLinks","document","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","Array","from","script","addEventListener","script1","src","fetch"],"mappings":"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","ignoreList":[0]}}]
+    {"offset": {"line": 762, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","includedList","modulesPromises","includedModuleChunksList","moduleChunksPromises","promise","moduleChunksToLoad","_iteratorError","moduleChunk","_iteratorError1","moduleChunkToLoad","promise1","_iteratorError2","includedModuleChunk","_iteratorError3","included","loadChunkPath","map","has","get","length","every","p","Promise","all","moduleChunks","filter","Set","add","set","push","path","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1249, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/build-base.ts"],"sourcesContent":["/// <reference path=\"./runtime-base.ts\" />\n/// <reference path=\"./dummy.ts\" />\n\nconst moduleCache: ModuleCache<Module> = {}\ncontextPrototype.c = moduleCache\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = moduleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// Used by the backend\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  Module\n> = (id, sourceModule) => {\n  const module = moduleCache[id]\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData))\n  }\n\n  const module: Module = createModuleObject(id)\n  const exports = module.exports\n\n  moduleCache[id] = module\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  const context = new (Context as any as ContextConstructor<Module>)(\n    module,\n    exports\n  )\n  try {\n    moduleFactory(context, module, exports)\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories\n    )\n  }\n\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n"],"names":["moduleCache","contextPrototype","c","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","Parent","sourceType","sourceData","moduleFactory","moduleFactories","get","Error","factoryNotAvailableMessage","createModuleObject","exports","context","Context","namespaceObject","interopEsm","registerChunk","registration","getPathFromScript","runtimeParams","length","undefined","installCompressedModuleFactories","BACKEND"],"mappings":"AAAA,0CAA0C;AAC1C,mCAAmC;AAEnC,IAAMA,cAAmC,CAAC;AAC1CC,iBAAiBC,CAAC,GAAGF;AAErB;;CAEC,GACD,aAAa;AACb,6DAA6D;AAC7D,SAASG,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,IAAMC,SAASN,WAAW,CAACK,SAAS;IACpC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,sBAAsB;AACtB,aAAa;AACb,6DAA6D;AAC7D,IAAMO,mCAEF,SAACC,IAAIC;IACP,IAAMP,SAASN,WAAW,CAACY,GAAG;IAE9B,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWK,MAAM,EAAED,aAAaD,EAAE;AACjE;AAEA,SAASJ,kBACPI,EAAY,EACZG,UAAsB,EACtBC,UAAsB;IAEtB,IAAMC,gBAAgBC,gBAAgBC,GAAG,CAACP;IAC1C,IAAI,OAAOK,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAIG,MAAMC,2BAA2BT,IAAIG,YAAYC;IAC7D;IAEA,IAAMV,SAAiBgB,mBAAmBV;IAC1C,IAAMW,UAAUjB,OAAOiB,OAAO;IAE9BvB,WAAW,CAACY,GAAG,GAAGN;IAElB,4EAA4E;IAC5E,IAAMkB,UAAU,IAAKC,QACnBnB,QACAiB;IAEF,IAAI;QACFN,cAAcO,SAASlB,QAAQiB;IACjC,EAAE,OAAOhB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOoB,eAAe,IAAIpB,OAAOiB,OAAO,KAAKjB,OAAOoB,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWrB,OAAOiB,OAAO,EAAEjB,OAAOoB,eAAe;IACnD;IAEA,OAAOpB;AACT;AAEA,6DAA6D;AAC7D,SAASsB,cAAcC,YAA+B;IACpD,IAAMzB,YAAY0B,kBAAkBD,YAAY,CAAC,EAAE;IACnD,IAAIE;IACJ,8GAA8G;IAC9G,IAAIF,aAAaG,MAAM,KAAK,GAAG;QAC7BD,gBAAgBF,YAAY,CAAC,EAAE;IACjC,OAAO;QACLE,gBAAgBE;QAChBC,iCACEL,cACA,WAAW,GAAG,GACdX;IAEJ;IAEA,OAAOiB,QAAQP,aAAa,CAACxB,WAAW2B;AAC1C","ignoreList":[0]}},
+    {"offset": {"line": 1320, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","_self_TURBOPACK_CHUNK_SUFFIX","_document_currentScript_getAttribute","TURBOPACK_CHUNK_SUFFIX","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","resolver","_iteratorError","otherChunkData","otherChunkPath","otherChunkUrl","_iteratorError1","moduleId","getChunkRelativeUrl","getOrCreateResolver","resolve","otherChunks","getChunkPath","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","instance","fetchWebAssembly","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","self","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","document","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","Array","from","script","addEventListener","script1","src","fetch"],"mappings":"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","ignoreList":[0]}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js
new file mode 100644
index 00000000000000..f405dfe33744f4
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js
@@ -0,0 +1,3 @@
+console.log('index.js')
+const url = new URL('./worker.js', import.meta.url)
+new Worker(url)
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js
new file mode 100644
index 00000000000000..505a1468977903
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js
@@ -0,0 +1,2 @@
+console.log('worker.js')
+self.postMessage('hello')
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/options.json b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/options.json
new file mode 100644
index 00000000000000..a04426e250932b
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/options.json
@@ -0,0 +1,6 @@
+{
+  "runtime": "Browser",
+  "runtimeType": "Development",
+  "minifyType": "NoMinify",
+  "environment": "Browser"
+}
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/6642e_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/6642e_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js
new file mode 100644
index 00000000000000..3979b9ac22a124
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/6642e_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js
@@ -0,0 +1,62 @@
+/**
+ * Worker entrypoint bootstrap.
+ */ ;
+(()=>{
+    function abort(message) {
+        console.error(message);
+        throw new Error(message);
+    }
+    // Security: Ensure this code is running in a worker environment to prevent
+    // the worker entrypoint being used as an XSS gadget. If this is a worker, we
+    // know that the origin of the caller is the same as our origin.
+    if (typeof self['WorkerGlobalScope'] === 'undefined' || !(self instanceof self['WorkerGlobalScope'])) {
+        abort('Worker entrypoint must be loaded in a worker context');
+    }
+    const url = new URL(location.href);
+    // Try querystring first (SharedWorker), then hash (regular Worker)
+    let paramsString = url.searchParams.get('params');
+    if (!paramsString && url.hash.startsWith('#params=')) {
+        paramsString = decodeURIComponent(url.hash.slice('#params='.length));
+    }
+    if (!paramsString) abort('Missing worker bootstrap config');
+    // Safety: this string requires that a script on the same origin has loaded
+    // this code as a module. We still don't fully trust it, so we'll validate the
+    // types and ensure that the next chunk URLs are same-origin.
+    const config = JSON.parse(paramsString);
+    const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : '';
+    const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : '';
+    // In a normal browser context, the runtime can figure out which chunk is
+    // currently executing via `document.currentScript`. Workers don't have that
+    // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead
+    // (`reverse()`d below).
+    //
+    // Each chunk pops its URL off the front of the array when it runs, so we need
+    // to store them in reverse order to make sure the first chunk to execute sees
+    // its own URL at the front.
+    const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : [];
+    Object.assign(self, {
+        TURBOPACK_CHUNK_SUFFIX,
+        TURBOPACK_NEXT_CHUNK_URLS,
+        NEXT_DEPLOYMENT_ID
+    });
+    if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+        const scriptsToLoad = [];
+        for (const chunk of TURBOPACK_NEXT_CHUNK_URLS){
+            // Chunks are relative to the origin.
+            const chunkUrl = new URL(chunk, location.origin);
+            // Security: Only load scripts from the same origin. This prevents this
+            // worker entrypoint from being used as a gadget to load scripts from
+            // foreign origins if someone happens to find a separate XSS vector
+            // elsewhere on this origin.
+            if (chunkUrl.origin !== location.origin) {
+                abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`);
+            }
+            scriptsToLoad.push(chunkUrl.toString());
+        }
+        TURBOPACK_NEXT_CHUNK_URLS.reverse();
+        importScripts(...scriptsToLoad);
+    }
+})();
+
+
+//# sourceMappingURL=turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js.map
new file mode 100644
index 00000000000000..2092500cff64fb
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js.map
@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","err","asyncModule","body","hasAwait","depQueues","Set","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"AAAA;;;;;CAKC,GAED,oDAAoD,GAEpD,6CAA6C;AAU7C,MAAMA,qBAAqB,IAAIC;AAE/B;;CAEC,GACD,SAASC,QAEPC,MAAc,EACdC,OAAgB;IAEhB,IAAI,CAACC,CAAC,GAAGF;IACT,gFAAgF;IAChF,yEAAyE;IACzE,+CAA+C;IAC/C,8EAA8E;IAC9E,sEAAsE;IACtE,iBAAiB;IACjB,4FAA4F;IAC5F,IAAI,CAACG,CAAC,GAAGF;AACX;AACA,MAAMG,mBAAmBL,QAAQM,SAAS;AA+B1C,MAAMC,iBAAiBC,OAAOF,SAAS,CAACC,cAAc;AACtD,MAAME,cAAc,OAAOC,WAAW,eAAeA,OAAOD,WAAW;AAEvE,SAASE,WACPC,GAAQ,EACRC,IAAiB,EACjBC,OAA2C;IAE3C,IAAI,CAACP,eAAeQ,IAAI,CAACH,KAAKC,OAAOL,OAAOQ,cAAc,CAACJ,KAAKC,MAAMC;AACxE;AAEA,SAASG,qBACPC,WAAgC,EAChCC,EAAY;IAEZ,IAAIlB,SAASiB,WAAW,CAACC,GAAG;IAC5B,IAAI,CAAClB,QAAQ;QACX,0FAA0F;QAC1F,4DAA4D;QAC5DA,SAASmB,mBAAmBD;QAC5BD,WAAW,CAACC,GAAG,GAAGlB;IACpB;IACA,OAAOA;AACT;AAEA;;CAEC,GACD,SAASmB,mBAAmBD,EAAY;IACtC,OAAO;QACLjB,SAAS,CAAC;QACVmB,OAAOC;QACPH;QACAI,iBAAiBD;IACnB;AACF;AAGA,MAAME,mBAAmB;AAUzB;;CAEC,GACD,SAASC,IAAIvB,OAAgB,EAAEwB,QAAqB;IAClDf,WAAWT,SAAS,cAAc;QAAEyB,OAAO;IAAK;IAChD,IAAIlB,aAAaE,WAAWT,SAASO,aAAa;QAAEkB,OAAO;IAAS;IACpE,IAAIC,IAAI;IACR,MAAOA,IAAIF,SAASG,MAAM,CAAE;QAC1B,MAAMC,WAAWJ,QAAQ,CAACE,IAAI;QAC9B,MAAMG,gBAAgBL,QAAQ,CAACE,IAAI;QACnC,IAAI,OAAOG,kBAAkB,UAAU;YACrC,IAAIA,kBAAkBP,kBAAkB;gBACtCb,WAAWT,SAAS4B,UAAU;oBAC5BH,OAAOD,QAAQ,CAACE,IAAI;oBACpBI,YAAY;oBACZC,UAAU;gBACZ;YACF,OAAO;gBACL,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEH,eAAe;YACpD;QACF,OAAO;YACL,MAAMI,WAAWJ;YACjB,IAAI,OAAOL,QAAQ,CAACE,EAAE,KAAK,YAAY;gBACrC,MAAMQ,WAAWV,QAAQ,CAACE,IAAI;gBAC9BjB,WAAWT,SAAS4B,UAAU;oBAC5BO,KAAKF;oBACLG,KAAKF;oBACLJ,YAAY;gBACd;YACF,OAAO;gBACLrB,WAAWT,SAAS4B,UAAU;oBAC5BO,KAAKF;oBACLH,YAAY;gBACd;YACF;QACF;IACF;IACAxB,OAAO+B,IAAI,CAACrC;AACd;AAEA;;CAEC,GACD,SAASsC,UAEPd,QAAqB,EACrBP,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACAH,OAAOsB,eAAe,GAAGrB;IACzBuB,IAAIvB,SAASwB;AACf;AACArB,iBAAiBqC,CAAC,GAAGF;AAGrB,SAASG,qBACP1C,MAAc,EACdC,OAAgB;IAEhB,IAAI0C,oBACF9C,mBAAmBuC,GAAG,CAACpC;IAEzB,IAAI,CAAC2C,mBAAmB;QACtB9C,mBAAmBwC,GAAG,CAACrC,QAAS2C,oBAAoB,EAAE;QACtD3C,OAAOC,OAAO,GAAGD,OAAOsB,eAAe,GAAG,IAAIsB,MAAM3C,SAAS;YAC3DmC,KAAIS,MAAM,EAAEC,IAAI;gBACd,IACExC,eAAeQ,IAAI,CAAC+B,QAAQC,SAC5BA,SAAS,aACTA,SAAS,cACT;oBACA,OAAOC,QAAQX,GAAG,CAACS,QAAQC;gBAC7B;gBACA,KAAK,MAAMnC,OAAOgC,kBAAoB;oBACpC,MAAMjB,QAAQqB,QAAQX,GAAG,CAACzB,KAAKmC;oBAC/B,IAAIpB,UAAUL,WAAW,OAAOK;gBAClC;gBACA,OAAOL;YACT;YACA2B,SAAQH,MAAM;gBACZ,MAAMI,OAAOF,QAAQC,OAAO,CAACH;gBAC7B,KAAK,MAAMlC,OAAOgC,kBAAoB;oBACpC,KAAK,MAAMO,OAAOH,QAAQC,OAAO,CAACrC,KAAM;wBACtC,IAAIuC,QAAQ,aAAa,CAACD,KAAKE,QAAQ,CAACD,MAAMD,KAAKG,IAAI,CAACF;oBAC1D;gBACF;gBACA,OAAOD;YACT;QACF;IACF;IACA,OAAON;AACT;AAEA;;CAEC,GACD,SAASU,cAEPC,MAA2B,EAC3BpC,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACA,MAAMwC,oBAAoBD,qBAAqB1C,QAAQC;IAEvD,IAAI,OAAOqD,WAAW,YAAYA,WAAW,MAAM;QACjDX,kBAAkBS,IAAI,CAACE;IACzB;AACF;AACAlD,iBAAiBmD,CAAC,GAAGF;AAErB,SAASG,YAEP9B,KAAU,EACVR,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGyB;AACnB;AACAtB,iBAAiBqD,CAAC,GAAGD;AAErB,SAASE,gBAEPC,SAAc,EACdzC,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGD,OAAOsB,eAAe,GAAGqC;AAC5C;AACAvD,iBAAiBwD,CAAC,GAAGF;AAErB,SAASG,aAAalD,GAAiC,EAAEuC,GAAoB;IAC3E,OAAO,IAAMvC,GAAG,CAACuC,IAAI;AACvB;AAEA;;CAEC,GACD,MAAMY,WAA8BvD,OAAOwD,cAAc,GACrD,CAACpD,MAAQJ,OAAOwD,cAAc,CAACpD,OAC/B,CAACA,MAAQA,IAAIqD,SAAS;AAE1B,iDAAiD,GACjD,MAAMC,kBAAkB;IAAC;IAAMH,SAAS,CAAC;IAAIA,SAAS,EAAE;IAAGA,SAASA;CAAU;AAE9E;;;;;;CAMC,GACD,SAASI,WACPC,GAAY,EACZC,EAAsB,EACtBC,kBAA4B;IAE5B,MAAM5C,WAAwB,EAAE;IAChC,IAAI6C,kBAAkB,CAAC;IACvB,IACE,IAAIC,UAAUJ,KACd,CAAC,OAAOI,YAAY,YAAY,OAAOA,YAAY,UAAU,KAC7D,CAACN,gBAAgBd,QAAQ,CAACoB,UAC1BA,UAAUT,SAASS,SACnB;QACA,KAAK,MAAMrB,OAAO3C,OAAOiE,mBAAmB,CAACD,SAAU;YACrD9C,SAAS2B,IAAI,CAACF,KAAKW,aAAaM,KAAKjB;YACrC,IAAIoB,oBAAoB,CAAC,KAAKpB,QAAQ,WAAW;gBAC/CoB,kBAAkB7C,SAASG,MAAM,GAAG;YACtC;QACF;IACF;IAEA,6BAA6B;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,CAACyC,sBAAsBC,mBAAmB,CAAC,GAAG;QACjD,8FAA8F;QAC9F,IAAIA,mBAAmB,GAAG;YACxB,oCAAoC;YACpC7C,SAASgD,MAAM,CAACH,iBAAiB,GAAG/C,kBAAkB4C;QACxD,OAAO;YACL1C,SAAS2B,IAAI,CAAC,WAAW7B,kBAAkB4C;QAC7C;IACF;IAEA3C,IAAI4C,IAAI3C;IACR,OAAO2C;AACT;AAEA,SAASM,SAASP,GAAsB;IACtC,IAAI,OAAOA,QAAQ,YAAY;QAC7B,OAAO,SAAqB,GAAGQ,IAAW;YACxC,OAAOR,IAAIS,KAAK,CAAC,IAAI,EAAED;QACzB;IACF,OAAO;QACL,OAAOpE,OAAOsE,MAAM,CAAC;IACvB;AACF;AAEA,SAASC,UAEP5D,EAAY;IAEZ,MAAMlB,SAAS+E,iCAAiC7D,IAAI,IAAI,CAAChB,CAAC;IAE1D,8DAA8D;IAC9D,IAAIF,OAAOsB,eAAe,EAAE,OAAOtB,OAAOsB,eAAe;IAEzD,iGAAiG;IACjG,MAAM6C,MAAMnE,OAAOC,OAAO;IAC1B,OAAQD,OAAOsB,eAAe,GAAG4C,WAC/BC,KACAO,SAASP,MACTA,OAAO,AAACA,IAAYa,UAAU;AAElC;AACA5E,iBAAiBuB,CAAC,GAAGmD;AAErB,SAASG,YAEPC,QAAkB;IAElB,MAAMC,SAAS,IAAI,CAACC,CAAC,CAACF;IAGtB,OAAOC,OAAOL,UAAUO,IAAI,CAAC,IAAI;AACnC;AACAjF,iBAAiBkF,CAAC,GAAGL;AAErB,+EAA+E;AAC/E,6EAA6E;AAC7E,MAAMM,iBACJ,aAAa;AACb,OAAOC,YAAY,aAEfA,UACA,SAASC;IACP,MAAM,IAAIxD,MAAM;AAClB;AACN7B,iBAAiBsF,CAAC,GAAGH;AAErB,SAASI,gBAEPzE,EAAY;IAEZ,OAAO6D,iCAAiC7D,IAAI,IAAI,CAAChB,CAAC,EAAED,OAAO;AAC7D;AACAG,iBAAiBgF,CAAC,GAAGO;AAErB;;;;;;CAMC,GACD,SAASC,aAAaC,OAAe;IACnC,wFAAwF;IACxF,4DAA4D;IAC5D,MAAMC,YAAYD,QAAQE,OAAO,CAAC;IAClC,IAAID,cAAc,CAAC,GAAG;QACpBD,UAAUA,QAAQG,SAAS,CAAC,GAAGF;IACjC;IAEA,MAAMG,aAAaJ,QAAQE,OAAO,CAAC;IACnC,IAAIE,eAAe,CAAC,GAAG;QACrBJ,UAAUA,QAAQG,SAAS,CAAC,GAAGC;IACjC;IAEA,OAAOJ;AACT;AACA;;CAEC,GACD,SAASK,cAAcC,GAAqB;IAC1C,SAASD,cAAchF,EAAU;QAC/BA,KAAK0E,aAAa1E;QAClB,IAAIZ,eAAeQ,IAAI,CAACqF,KAAKjF,KAAK;YAChC,OAAOiF,GAAG,CAACjF,GAAG,CAAClB,MAAM;QACvB;QAEA,MAAMG,IAAI,IAAI8B,MAAM,CAAC,oBAAoB,EAAEf,GAAG,CAAC,CAAC;QAC9Cf,EAAUiG,IAAI,GAAG;QACnB,MAAMjG;IACR;IAEA+F,cAAcjD,IAAI,GAAG;QACnB,OAAO1C,OAAO0C,IAAI,CAACkD;IACrB;IAEAD,cAAcG,OAAO,GAAG,CAACnF;QACvBA,KAAK0E,aAAa1E;QAClB,IAAIZ,eAAeQ,IAAI,CAACqF,KAAKjF,KAAK;YAChC,OAAOiF,GAAG,CAACjF,GAAG,CAACA,EAAE;QACnB;QAEA,MAAMf,IAAI,IAAI8B,MAAM,CAAC,oBAAoB,EAAEf,GAAG,CAAC,CAAC;QAC9Cf,EAAUiG,IAAI,GAAG;QACnB,MAAMjG;IACR;IAEA+F,cAAcI,MAAM,GAAG,OAAOpF;QAC5B,OAAO,MAAOgF,cAAchF;IAC9B;IAEA,OAAOgF;AACT;AACA9F,iBAAiBmG,CAAC,GAAGL;AAErB;;CAEC,GACD,SAASM,aAAaC,SAAoB;IACxC,OAAO,OAAOA,cAAc,WAAWA,YAAYA,UAAUC,IAAI;AACnE;AAEA,SAASC,UAAmBC,YAAiB;IAC3C,OACEA,gBAAgB,QAChB,OAAOA,iBAAiB,YACxB,UAAUA,gBACV,OAAOA,aAAaC,IAAI,KAAK;AAEjC;AAEA,SAASC,iBAA+BnG,GAAM;IAC5C,OAAOoG,mBAAmBpG;AAC5B;AAEA,SAASqG;IACP,IAAIX;IACJ,IAAIY;IAEJ,MAAMC,UAAU,IAAIC,QAAW,CAACC,KAAKC;QACnCJ,SAASI;QACThB,UAAUe;IACZ;IAEA,OAAO;QACLF;QACAb,SAASA;QACTY,QAAQA;IACV;AACF;AAEA,gFAAgF;AAChF,0CAA0C;AAC1C,yBAAyB;AACzB,8BAA8B;AAC9B,6EAA6E;AAC7E,wEAAwE;AACxE,SAASK,iCACPC,YAAuC,EACvCC,MAAc,EACdC,eAAgC,EAChCC,WAAoC;IAEpC,IAAI/F,IAAI6F;IACR,MAAO7F,IAAI4F,aAAa3F,MAAM,CAAE;QAC9B,IAAIsD,WAAWqC,YAAY,CAAC5F,EAAE;QAC9B,IAAIgG,MAAMhG,IAAI;QACd,4BAA4B;QAC5B,MACEgG,MAAMJ,aAAa3F,MAAM,IACzB,OAAO2F,YAAY,CAACI,IAAI,KAAK,WAC7B;YACAA;QACF;QACA,IAAIA,QAAQJ,aAAa3F,MAAM,EAAE;YAC/B,MAAM,IAAIK,MAAM;QAClB;QACA,+FAA+F;QAC/F,sFAAsF;QACtF,IAAI,CAACwF,gBAAgBG,GAAG,CAAC1C,WAAW;YAClC,MAAM2C,kBAAkBN,YAAY,CAACI,IAAI;YACzCG,uBAAuBD;YACvBH,cAAcxC;YACd,MAAOvD,IAAIgG,KAAKhG,IAAK;gBACnBuD,WAAWqC,YAAY,CAAC5F,EAAE;gBAC1B8F,gBAAgBpF,GAAG,CAAC6C,UAAU2C;YAChC;QACF;QACAlG,IAAIgG,MAAM,GAAE,sFAAsF;IACpG;AACF;AAEA,2CAA2C;AAC3C,+HAA+H;AAE/H,MAAMZ,kBAAkBtG,OAAO;AAC/B,MAAMsH,mBAAmBtH,OAAO;AAChC,MAAMuH,iBAAiBvH,OAAO;AAa9B,SAASwH,aAAaC,KAAkB;IACtC,IAAIA,SAASA,MAAMC,MAAM,QAA2B;QAClDD,MAAMC,MAAM;QACZD,MAAME,OAAO,CAAC,CAACC,KAAOA,GAAGC,UAAU;QACnCJ,MAAME,OAAO,CAAC,CAACC,KAAQA,GAAGC,UAAU,KAAKD,GAAGC,UAAU,KAAKD;IAC7D;AACF;AAYA,SAASE,SAASC,IAAW;IAC3B,OAAOA,KAAKrC,GAAG,CAAC,CAACsC;QACf,IAAIA,QAAQ,QAAQ,OAAOA,QAAQ,UAAU;YAC3C,IAAI3B,iBAAiB2B,MAAM,OAAOA;YAClC,IAAI9B,UAAU8B,MAAM;gBAClB,MAAMP,QAAoB3H,OAAOmI,MAAM,CAAC,EAAE,EAAE;oBAC1CP,MAAM;gBACR;gBAEA,MAAMxH,MAAsB;oBAC1B,CAACoH,iBAAiB,EAAE,CAAC;oBACrB,CAAChB,gBAAgB,EAAE,CAACsB,KAAoCA,GAAGH;gBAC7D;gBAEAO,IAAI5B,IAAI,CACN,CAACO;oBACCzG,GAAG,CAACoH,iBAAiB,GAAGX;oBACxBa,aAAaC;gBACf,GACA,CAACS;oBACChI,GAAG,CAACqH,eAAe,GAAGW;oBACtBV,aAAaC;gBACf;gBAGF,OAAOvH;YACT;QACF;QAEA,OAAO;YACL,CAACoH,iBAAiB,EAAEU;YACpB,CAAC1B,gBAAgB,EAAE,KAAO;QAC5B;IACF;AACF;AAEA,SAAS6B,YAEPC,IAKS,EACTC,QAAiB;IAEjB,MAAM9I,SAAS,IAAI,CAACE,CAAC;IACrB,MAAMgI,QAAgCY,WAClCvI,OAAOmI,MAAM,CAAC,EAAE,EAAE;QAAEP,MAAM;IAAsB,KAChD9G;IAEJ,MAAM0H,YAA6B,IAAIC;IAEvC,MAAM,EAAE3C,OAAO,EAAEY,MAAM,EAAEC,SAAS+B,UAAU,EAAE,GAAGjC;IAEjD,MAAME,UAA8B3G,OAAOmI,MAAM,CAACO,YAAY;QAC5D,CAAClB,iBAAiB,EAAE/H,OAAOC,OAAO;QAClC,CAAC8G,gBAAgB,EAAE,CAACsB;YAClBH,SAASG,GAAGH;YACZa,UAAUX,OAAO,CAACC;YAClBnB,OAAO,CAAC,QAAQ,CAAC,KAAO;QAC1B;IACF;IAEA,MAAMgC,aAAiC;QACrC9G;YACE,OAAO8E;QACT;QACA7E,KAAIoB,CAAM;YACR,qCAAqC;YACrC,IAAIA,MAAMyD,SAAS;gBACjBA,OAAO,CAACa,iBAAiB,GAAGtE;YAC9B;QACF;IACF;IAEAlD,OAAOQ,cAAc,CAACf,QAAQ,WAAWkJ;IACzC3I,OAAOQ,cAAc,CAACf,QAAQ,mBAAmBkJ;IAEjD,SAASC,wBAAwBX,IAAW;QAC1C,MAAMY,cAAcb,SAASC;QAE7B,MAAMa,YAAY,IAChBD,YAAYjD,GAAG,CAAC,CAACmD;gBACf,IAAIA,CAAC,CAACtB,eAAe,EAAE,MAAMsB,CAAC,CAACtB,eAAe;gBAC9C,OAAOsB,CAAC,CAACvB,iBAAiB;YAC5B;QAEF,MAAM,EAAEb,OAAO,EAAEb,OAAO,EAAE,GAAGW;QAE7B,MAAMqB,KAAmB9H,OAAOmI,MAAM,CAAC,IAAMrC,QAAQgD,YAAY;YAC/Df,YAAY;QACd;QAEA,SAASiB,QAAQC,CAAa;YAC5B,IAAIA,MAAMtB,SAAS,CAACa,UAAUnB,GAAG,CAAC4B,IAAI;gBACpCT,UAAUU,GAAG,CAACD;gBACd,IAAIA,KAAKA,EAAErB,MAAM,QAA6B;oBAC5CE,GAAGC,UAAU;oBACbkB,EAAEpG,IAAI,CAACiF;gBACT;YACF;QACF;QAEAe,YAAYjD,GAAG,CAAC,CAACsC,MAAQA,GAAG,CAAC1B,gBAAgB,CAACwC;QAE9C,OAAOlB,GAAGC,UAAU,GAAGpB,UAAUmC;IACnC;IAEA,SAASK,YAAYf,GAAS;QAC5B,IAAIA,KAAK;YACP1B,OAAQC,OAAO,CAACc,eAAe,GAAGW;QACpC,OAAO;YACLtC,QAAQa,OAAO,CAACa,iBAAiB;QACnC;QAEAE,aAAaC;IACf;IAEAW,KAAKM,yBAAyBO;IAE9B,IAAIxB,SAASA,MAAMC,MAAM,SAA0B;QACjDD,MAAMC,MAAM;IACd;AACF;AACA/H,iBAAiBuJ,CAAC,GAAGf;AAErB;;;;;;;;;CASC,GACD,MAAMgB,cAAc,SAASA,YAAuBC,QAAgB;IAClE,MAAMC,UAAU,IAAIC,IAAIF,UAAU;IAClC,MAAMG,SAA8B,CAAC;IACrC,IAAK,MAAM9G,OAAO4G,QAASE,MAAM,CAAC9G,IAAI,GAAG,AAAC4G,OAAe,CAAC5G,IAAI;IAC9D8G,OAAOC,IAAI,GAAGJ;IACdG,OAAOE,QAAQ,GAAGL,SAASM,OAAO,CAAC,UAAU;IAC7CH,OAAOI,MAAM,GAAGJ,OAAOK,QAAQ,GAAG;IAClCL,OAAOM,QAAQ,GAAGN,OAAOO,MAAM,GAAG,CAAC,GAAGC,QAAsBX;IAC5D,IAAK,MAAM3G,OAAO8G,OAChBzJ,OAAOQ,cAAc,CAAC,IAAI,EAAEmC,KAAK;QAC/BnB,YAAY;QACZ0I,cAAc;QACd/I,OAAOsI,MAAM,CAAC9G,IAAI;IACpB;AACJ;AACA0G,YAAYvJ,SAAS,GAAG0J,IAAI1J,SAAS;AACrCD,iBAAiBsK,CAAC,GAAGd;AAErB;;CAEC,GACD,SAASe,UAAUC,KAAY,EAAEC,cAAoC;IACnE,MAAM,IAAI5I,MAAM,CAAC,WAAW,EAAE4I,eAAeD,QAAQ;AACvD;AAEA;;CAEC,GACD,SAASE,YAAYC,SAAmB;IACtC,MAAM,IAAI9I,MAAM;AAClB;AACA7B,iBAAiB4K,CAAC,GAAGF;AAErB,kGAAkG;AAClG1K,iBAAiB6K,CAAC,GAAGC;AAMrB,SAASpD,uBAAuBqD,OAAiB;IAC/C,+DAA+D;IAC/D5K,OAAOQ,cAAc,CAACoK,SAAS,QAAQ;QACrCzJ,OAAO;IACT;AACF","ignoreList":[0]}},
+    {"offset": {"line": 514, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 747, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1766, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js.map
new file mode 100644
index 00000000000000..2092500cff64fb
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js.map
@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","err","asyncModule","body","hasAwait","depQueues","Set","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"AAAA;;;;;CAKC,GAED,oDAAoD,GAEpD,6CAA6C;AAU7C,MAAMA,qBAAqB,IAAIC;AAE/B;;CAEC,GACD,SAASC,QAEPC,MAAc,EACdC,OAAgB;IAEhB,IAAI,CAACC,CAAC,GAAGF;IACT,gFAAgF;IAChF,yEAAyE;IACzE,+CAA+C;IAC/C,8EAA8E;IAC9E,sEAAsE;IACtE,iBAAiB;IACjB,4FAA4F;IAC5F,IAAI,CAACG,CAAC,GAAGF;AACX;AACA,MAAMG,mBAAmBL,QAAQM,SAAS;AA+B1C,MAAMC,iBAAiBC,OAAOF,SAAS,CAACC,cAAc;AACtD,MAAME,cAAc,OAAOC,WAAW,eAAeA,OAAOD,WAAW;AAEvE,SAASE,WACPC,GAAQ,EACRC,IAAiB,EACjBC,OAA2C;IAE3C,IAAI,CAACP,eAAeQ,IAAI,CAACH,KAAKC,OAAOL,OAAOQ,cAAc,CAACJ,KAAKC,MAAMC;AACxE;AAEA,SAASG,qBACPC,WAAgC,EAChCC,EAAY;IAEZ,IAAIlB,SAASiB,WAAW,CAACC,GAAG;IAC5B,IAAI,CAAClB,QAAQ;QACX,0FAA0F;QAC1F,4DAA4D;QAC5DA,SAASmB,mBAAmBD;QAC5BD,WAAW,CAACC,GAAG,GAAGlB;IACpB;IACA,OAAOA;AACT;AAEA;;CAEC,GACD,SAASmB,mBAAmBD,EAAY;IACtC,OAAO;QACLjB,SAAS,CAAC;QACVmB,OAAOC;QACPH;QACAI,iBAAiBD;IACnB;AACF;AAGA,MAAME,mBAAmB;AAUzB;;CAEC,GACD,SAASC,IAAIvB,OAAgB,EAAEwB,QAAqB;IAClDf,WAAWT,SAAS,cAAc;QAAEyB,OAAO;IAAK;IAChD,IAAIlB,aAAaE,WAAWT,SAASO,aAAa;QAAEkB,OAAO;IAAS;IACpE,IAAIC,IAAI;IACR,MAAOA,IAAIF,SAASG,MAAM,CAAE;QAC1B,MAAMC,WAAWJ,QAAQ,CAACE,IAAI;QAC9B,MAAMG,gBAAgBL,QAAQ,CAACE,IAAI;QACnC,IAAI,OAAOG,kBAAkB,UAAU;YACrC,IAAIA,kBAAkBP,kBAAkB;gBACtCb,WAAWT,SAAS4B,UAAU;oBAC5BH,OAAOD,QAAQ,CAACE,IAAI;oBACpBI,YAAY;oBACZC,UAAU;gBACZ;YACF,OAAO;gBACL,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEH,eAAe;YACpD;QACF,OAAO;YACL,MAAMI,WAAWJ;YACjB,IAAI,OAAOL,QAAQ,CAACE,EAAE,KAAK,YAAY;gBACrC,MAAMQ,WAAWV,QAAQ,CAACE,IAAI;gBAC9BjB,WAAWT,SAAS4B,UAAU;oBAC5BO,KAAKF;oBACLG,KAAKF;oBACLJ,YAAY;gBACd;YACF,OAAO;gBACLrB,WAAWT,SAAS4B,UAAU;oBAC5BO,KAAKF;oBACLH,YAAY;gBACd;YACF;QACF;IACF;IACAxB,OAAO+B,IAAI,CAACrC;AACd;AAEA;;CAEC,GACD,SAASsC,UAEPd,QAAqB,EACrBP,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACAH,OAAOsB,eAAe,GAAGrB;IACzBuB,IAAIvB,SAASwB;AACf;AACArB,iBAAiBqC,CAAC,GAAGF;AAGrB,SAASG,qBACP1C,MAAc,EACdC,OAAgB;IAEhB,IAAI0C,oBACF9C,mBAAmBuC,GAAG,CAACpC;IAEzB,IAAI,CAAC2C,mBAAmB;QACtB9C,mBAAmBwC,GAAG,CAACrC,QAAS2C,oBAAoB,EAAE;QACtD3C,OAAOC,OAAO,GAAGD,OAAOsB,eAAe,GAAG,IAAIsB,MAAM3C,SAAS;YAC3DmC,KAAIS,MAAM,EAAEC,IAAI;gBACd,IACExC,eAAeQ,IAAI,CAAC+B,QAAQC,SAC5BA,SAAS,aACTA,SAAS,cACT;oBACA,OAAOC,QAAQX,GAAG,CAACS,QAAQC;gBAC7B;gBACA,KAAK,MAAMnC,OAAOgC,kBAAoB;oBACpC,MAAMjB,QAAQqB,QAAQX,GAAG,CAACzB,KAAKmC;oBAC/B,IAAIpB,UAAUL,WAAW,OAAOK;gBAClC;gBACA,OAAOL;YACT;YACA2B,SAAQH,MAAM;gBACZ,MAAMI,OAAOF,QAAQC,OAAO,CAACH;gBAC7B,KAAK,MAAMlC,OAAOgC,kBAAoB;oBACpC,KAAK,MAAMO,OAAOH,QAAQC,OAAO,CAACrC,KAAM;wBACtC,IAAIuC,QAAQ,aAAa,CAACD,KAAKE,QAAQ,CAACD,MAAMD,KAAKG,IAAI,CAACF;oBAC1D;gBACF;gBACA,OAAOD;YACT;QACF;IACF;IACA,OAAON;AACT;AAEA;;CAEC,GACD,SAASU,cAEPC,MAA2B,EAC3BpC,EAAwB;IAExB,IAAIlB;IACJ,IAAIC;IACJ,IAAIiB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;QACtCjB,UAAUD,OAAOC,OAAO;IAC1B,OAAO;QACLD,SAAS,IAAI,CAACE,CAAC;QACfD,UAAU,IAAI,CAACE,CAAC;IAClB;IACA,MAAMwC,oBAAoBD,qBAAqB1C,QAAQC;IAEvD,IAAI,OAAOqD,WAAW,YAAYA,WAAW,MAAM;QACjDX,kBAAkBS,IAAI,CAACE;IACzB;AACF;AACAlD,iBAAiBmD,CAAC,GAAGF;AAErB,SAASG,YAEP9B,KAAU,EACVR,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGyB;AACnB;AACAtB,iBAAiBqD,CAAC,GAAGD;AAErB,SAASE,gBAEPC,SAAc,EACdzC,EAAwB;IAExB,IAAIlB;IACJ,IAAIkB,MAAM,MAAM;QACdlB,SAASgB,qBAAqB,IAAI,CAACwB,CAAC,EAAEtB;IACxC,OAAO;QACLlB,SAAS,IAAI,CAACE,CAAC;IACjB;IACAF,OAAOC,OAAO,GAAGD,OAAOsB,eAAe,GAAGqC;AAC5C;AACAvD,iBAAiBwD,CAAC,GAAGF;AAErB,SAASG,aAAalD,GAAiC,EAAEuC,GAAoB;IAC3E,OAAO,IAAMvC,GAAG,CAACuC,IAAI;AACvB;AAEA;;CAEC,GACD,MAAMY,WAA8BvD,OAAOwD,cAAc,GACrD,CAACpD,MAAQJ,OAAOwD,cAAc,CAACpD,OAC/B,CAACA,MAAQA,IAAIqD,SAAS;AAE1B,iDAAiD,GACjD,MAAMC,kBAAkB;IAAC;IAAMH,SAAS,CAAC;IAAIA,SAAS,EAAE;IAAGA,SAASA;CAAU;AAE9E;;;;;;CAMC,GACD,SAASI,WACPC,GAAY,EACZC,EAAsB,EACtBC,kBAA4B;IAE5B,MAAM5C,WAAwB,EAAE;IAChC,IAAI6C,kBAAkB,CAAC;IACvB,IACE,IAAIC,UAAUJ,KACd,CAAC,OAAOI,YAAY,YAAY,OAAOA,YAAY,UAAU,KAC7D,CAACN,gBAAgBd,QAAQ,CAACoB,UAC1BA,UAAUT,SAASS,SACnB;QACA,KAAK,MAAMrB,OAAO3C,OAAOiE,mBAAmB,CAACD,SAAU;YACrD9C,SAAS2B,IAAI,CAACF,KAAKW,aAAaM,KAAKjB;YACrC,IAAIoB,oBAAoB,CAAC,KAAKpB,QAAQ,WAAW;gBAC/CoB,kBAAkB7C,SAASG,MAAM,GAAG;YACtC;QACF;IACF;IAEA,6BAA6B;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,CAACyC,sBAAsBC,mBAAmB,CAAC,GAAG;QACjD,8FAA8F;QAC9F,IAAIA,mBAAmB,GAAG;YACxB,oCAAoC;YACpC7C,SAASgD,MAAM,CAACH,iBAAiB,GAAG/C,kBAAkB4C;QACxD,OAAO;YACL1C,SAAS2B,IAAI,CAAC,WAAW7B,kBAAkB4C;QAC7C;IACF;IAEA3C,IAAI4C,IAAI3C;IACR,OAAO2C;AACT;AAEA,SAASM,SAASP,GAAsB;IACtC,IAAI,OAAOA,QAAQ,YAAY;QAC7B,OAAO,SAAqB,GAAGQ,IAAW;YACxC,OAAOR,IAAIS,KAAK,CAAC,IAAI,EAAED;QACzB;IACF,OAAO;QACL,OAAOpE,OAAOsE,MAAM,CAAC;IACvB;AACF;AAEA,SAASC,UAEP5D,EAAY;IAEZ,MAAMlB,SAAS+E,iCAAiC7D,IAAI,IAAI,CAAChB,CAAC;IAE1D,8DAA8D;IAC9D,IAAIF,OAAOsB,eAAe,EAAE,OAAOtB,OAAOsB,eAAe;IAEzD,iGAAiG;IACjG,MAAM6C,MAAMnE,OAAOC,OAAO;IAC1B,OAAQD,OAAOsB,eAAe,GAAG4C,WAC/BC,KACAO,SAASP,MACTA,OAAO,AAACA,IAAYa,UAAU;AAElC;AACA5E,iBAAiBuB,CAAC,GAAGmD;AAErB,SAASG,YAEPC,QAAkB;IAElB,MAAMC,SAAS,IAAI,CAACC,CAAC,CAACF;IAGtB,OAAOC,OAAOL,UAAUO,IAAI,CAAC,IAAI;AACnC;AACAjF,iBAAiBkF,CAAC,GAAGL;AAErB,+EAA+E;AAC/E,6EAA6E;AAC7E,MAAMM,iBACJ,aAAa;AACb,OAAOC,YAAY,aAEfA,UACA,SAASC;IACP,MAAM,IAAIxD,MAAM;AAClB;AACN7B,iBAAiBsF,CAAC,GAAGH;AAErB,SAASI,gBAEPzE,EAAY;IAEZ,OAAO6D,iCAAiC7D,IAAI,IAAI,CAAChB,CAAC,EAAED,OAAO;AAC7D;AACAG,iBAAiBgF,CAAC,GAAGO;AAErB;;;;;;CAMC,GACD,SAASC,aAAaC,OAAe;IACnC,wFAAwF;IACxF,4DAA4D;IAC5D,MAAMC,YAAYD,QAAQE,OAAO,CAAC;IAClC,IAAID,cAAc,CAAC,GAAG;QACpBD,UAAUA,QAAQG,SAAS,CAAC,GAAGF;IACjC;IAEA,MAAMG,aAAaJ,QAAQE,OAAO,CAAC;IACnC,IAAIE,eAAe,CAAC,GAAG;QACrBJ,UAAUA,QAAQG,SAAS,CAAC,GAAGC;IACjC;IAEA,OAAOJ;AACT;AACA;;CAEC,GACD,SAASK,cAAcC,GAAqB;IAC1C,SAASD,cAAchF,EAAU;QAC/BA,KAAK0E,aAAa1E;QAClB,IAAIZ,eAAeQ,IAAI,CAACqF,KAAKjF,KAAK;YAChC,OAAOiF,GAAG,CAACjF,GAAG,CAAClB,MAAM;QACvB;QAEA,MAAMG,IAAI,IAAI8B,MAAM,CAAC,oBAAoB,EAAEf,GAAG,CAAC,CAAC;QAC9Cf,EAAUiG,IAAI,GAAG;QACnB,MAAMjG;IACR;IAEA+F,cAAcjD,IAAI,GAAG;QACnB,OAAO1C,OAAO0C,IAAI,CAACkD;IACrB;IAEAD,cAAcG,OAAO,GAAG,CAACnF;QACvBA,KAAK0E,aAAa1E;QAClB,IAAIZ,eAAeQ,IAAI,CAACqF,KAAKjF,KAAK;YAChC,OAAOiF,GAAG,CAACjF,GAAG,CAACA,EAAE;QACnB;QAEA,MAAMf,IAAI,IAAI8B,MAAM,CAAC,oBAAoB,EAAEf,GAAG,CAAC,CAAC;QAC9Cf,EAAUiG,IAAI,GAAG;QACnB,MAAMjG;IACR;IAEA+F,cAAcI,MAAM,GAAG,OAAOpF;QAC5B,OAAO,MAAOgF,cAAchF;IAC9B;IAEA,OAAOgF;AACT;AACA9F,iBAAiBmG,CAAC,GAAGL;AAErB;;CAEC,GACD,SAASM,aAAaC,SAAoB;IACxC,OAAO,OAAOA,cAAc,WAAWA,YAAYA,UAAUC,IAAI;AACnE;AAEA,SAASC,UAAmBC,YAAiB;IAC3C,OACEA,gBAAgB,QAChB,OAAOA,iBAAiB,YACxB,UAAUA,gBACV,OAAOA,aAAaC,IAAI,KAAK;AAEjC;AAEA,SAASC,iBAA+BnG,GAAM;IAC5C,OAAOoG,mBAAmBpG;AAC5B;AAEA,SAASqG;IACP,IAAIX;IACJ,IAAIY;IAEJ,MAAMC,UAAU,IAAIC,QAAW,CAACC,KAAKC;QACnCJ,SAASI;QACThB,UAAUe;IACZ;IAEA,OAAO;QACLF;QACAb,SAASA;QACTY,QAAQA;IACV;AACF;AAEA,gFAAgF;AAChF,0CAA0C;AAC1C,yBAAyB;AACzB,8BAA8B;AAC9B,6EAA6E;AAC7E,wEAAwE;AACxE,SAASK,iCACPC,YAAuC,EACvCC,MAAc,EACdC,eAAgC,EAChCC,WAAoC;IAEpC,IAAI/F,IAAI6F;IACR,MAAO7F,IAAI4F,aAAa3F,MAAM,CAAE;QAC9B,IAAIsD,WAAWqC,YAAY,CAAC5F,EAAE;QAC9B,IAAIgG,MAAMhG,IAAI;QACd,4BAA4B;QAC5B,MACEgG,MAAMJ,aAAa3F,MAAM,IACzB,OAAO2F,YAAY,CAACI,IAAI,KAAK,WAC7B;YACAA;QACF;QACA,IAAIA,QAAQJ,aAAa3F,MAAM,EAAE;YAC/B,MAAM,IAAIK,MAAM;QAClB;QACA,+FAA+F;QAC/F,sFAAsF;QACtF,IAAI,CAACwF,gBAAgBG,GAAG,CAAC1C,WAAW;YAClC,MAAM2C,kBAAkBN,YAAY,CAACI,IAAI;YACzCG,uBAAuBD;YACvBH,cAAcxC;YACd,MAAOvD,IAAIgG,KAAKhG,IAAK;gBACnBuD,WAAWqC,YAAY,CAAC5F,EAAE;gBAC1B8F,gBAAgBpF,GAAG,CAAC6C,UAAU2C;YAChC;QACF;QACAlG,IAAIgG,MAAM,GAAE,sFAAsF;IACpG;AACF;AAEA,2CAA2C;AAC3C,+HAA+H;AAE/H,MAAMZ,kBAAkBtG,OAAO;AAC/B,MAAMsH,mBAAmBtH,OAAO;AAChC,MAAMuH,iBAAiBvH,OAAO;AAa9B,SAASwH,aAAaC,KAAkB;IACtC,IAAIA,SAASA,MAAMC,MAAM,QAA2B;QAClDD,MAAMC,MAAM;QACZD,MAAME,OAAO,CAAC,CAACC,KAAOA,GAAGC,UAAU;QACnCJ,MAAME,OAAO,CAAC,CAACC,KAAQA,GAAGC,UAAU,KAAKD,GAAGC,UAAU,KAAKD;IAC7D;AACF;AAYA,SAASE,SAASC,IAAW;IAC3B,OAAOA,KAAKrC,GAAG,CAAC,CAACsC;QACf,IAAIA,QAAQ,QAAQ,OAAOA,QAAQ,UAAU;YAC3C,IAAI3B,iBAAiB2B,MAAM,OAAOA;YAClC,IAAI9B,UAAU8B,MAAM;gBAClB,MAAMP,QAAoB3H,OAAOmI,MAAM,CAAC,EAAE,EAAE;oBAC1CP,MAAM;gBACR;gBAEA,MAAMxH,MAAsB;oBAC1B,CAACoH,iBAAiB,EAAE,CAAC;oBACrB,CAAChB,gBAAgB,EAAE,CAACsB,KAAoCA,GAAGH;gBAC7D;gBAEAO,IAAI5B,IAAI,CACN,CAACO;oBACCzG,GAAG,CAACoH,iBAAiB,GAAGX;oBACxBa,aAAaC;gBACf,GACA,CAACS;oBACChI,GAAG,CAACqH,eAAe,GAAGW;oBACtBV,aAAaC;gBACf;gBAGF,OAAOvH;YACT;QACF;QAEA,OAAO;YACL,CAACoH,iBAAiB,EAAEU;YACpB,CAAC1B,gBAAgB,EAAE,KAAO;QAC5B;IACF;AACF;AAEA,SAAS6B,YAEPC,IAKS,EACTC,QAAiB;IAEjB,MAAM9I,SAAS,IAAI,CAACE,CAAC;IACrB,MAAMgI,QAAgCY,WAClCvI,OAAOmI,MAAM,CAAC,EAAE,EAAE;QAAEP,MAAM;IAAsB,KAChD9G;IAEJ,MAAM0H,YAA6B,IAAIC;IAEvC,MAAM,EAAE3C,OAAO,EAAEY,MAAM,EAAEC,SAAS+B,UAAU,EAAE,GAAGjC;IAEjD,MAAME,UAA8B3G,OAAOmI,MAAM,CAACO,YAAY;QAC5D,CAAClB,iBAAiB,EAAE/H,OAAOC,OAAO;QAClC,CAAC8G,gBAAgB,EAAE,CAACsB;YAClBH,SAASG,GAAGH;YACZa,UAAUX,OAAO,CAACC;YAClBnB,OAAO,CAAC,QAAQ,CAAC,KAAO;QAC1B;IACF;IAEA,MAAMgC,aAAiC;QACrC9G;YACE,OAAO8E;QACT;QACA7E,KAAIoB,CAAM;YACR,qCAAqC;YACrC,IAAIA,MAAMyD,SAAS;gBACjBA,OAAO,CAACa,iBAAiB,GAAGtE;YAC9B;QACF;IACF;IAEAlD,OAAOQ,cAAc,CAACf,QAAQ,WAAWkJ;IACzC3I,OAAOQ,cAAc,CAACf,QAAQ,mBAAmBkJ;IAEjD,SAASC,wBAAwBX,IAAW;QAC1C,MAAMY,cAAcb,SAASC;QAE7B,MAAMa,YAAY,IAChBD,YAAYjD,GAAG,CAAC,CAACmD;gBACf,IAAIA,CAAC,CAACtB,eAAe,EAAE,MAAMsB,CAAC,CAACtB,eAAe;gBAC9C,OAAOsB,CAAC,CAACvB,iBAAiB;YAC5B;QAEF,MAAM,EAAEb,OAAO,EAAEb,OAAO,EAAE,GAAGW;QAE7B,MAAMqB,KAAmB9H,OAAOmI,MAAM,CAAC,IAAMrC,QAAQgD,YAAY;YAC/Df,YAAY;QACd;QAEA,SAASiB,QAAQC,CAAa;YAC5B,IAAIA,MAAMtB,SAAS,CAACa,UAAUnB,GAAG,CAAC4B,IAAI;gBACpCT,UAAUU,GAAG,CAACD;gBACd,IAAIA,KAAKA,EAAErB,MAAM,QAA6B;oBAC5CE,GAAGC,UAAU;oBACbkB,EAAEpG,IAAI,CAACiF;gBACT;YACF;QACF;QAEAe,YAAYjD,GAAG,CAAC,CAACsC,MAAQA,GAAG,CAAC1B,gBAAgB,CAACwC;QAE9C,OAAOlB,GAAGC,UAAU,GAAGpB,UAAUmC;IACnC;IAEA,SAASK,YAAYf,GAAS;QAC5B,IAAIA,KAAK;YACP1B,OAAQC,OAAO,CAACc,eAAe,GAAGW;QACpC,OAAO;YACLtC,QAAQa,OAAO,CAACa,iBAAiB;QACnC;QAEAE,aAAaC;IACf;IAEAW,KAAKM,yBAAyBO;IAE9B,IAAIxB,SAASA,MAAMC,MAAM,SAA0B;QACjDD,MAAMC,MAAM;IACd;AACF;AACA/H,iBAAiBuJ,CAAC,GAAGf;AAErB;;;;;;;;;CASC,GACD,MAAMgB,cAAc,SAASA,YAAuBC,QAAgB;IAClE,MAAMC,UAAU,IAAIC,IAAIF,UAAU;IAClC,MAAMG,SAA8B,CAAC;IACrC,IAAK,MAAM9G,OAAO4G,QAASE,MAAM,CAAC9G,IAAI,GAAG,AAAC4G,OAAe,CAAC5G,IAAI;IAC9D8G,OAAOC,IAAI,GAAGJ;IACdG,OAAOE,QAAQ,GAAGL,SAASM,OAAO,CAAC,UAAU;IAC7CH,OAAOI,MAAM,GAAGJ,OAAOK,QAAQ,GAAG;IAClCL,OAAOM,QAAQ,GAAGN,OAAOO,MAAM,GAAG,CAAC,GAAGC,QAAsBX;IAC5D,IAAK,MAAM3G,OAAO8G,OAChBzJ,OAAOQ,cAAc,CAAC,IAAI,EAAEmC,KAAK;QAC/BnB,YAAY;QACZ0I,cAAc;QACd/I,OAAOsI,MAAM,CAAC9G,IAAI;IACpB;AACJ;AACA0G,YAAYvJ,SAAS,GAAG0J,IAAI1J,SAAS;AACrCD,iBAAiBsK,CAAC,GAAGd;AAErB;;CAEC,GACD,SAASe,UAAUC,KAAY,EAAEC,cAAoC;IACnE,MAAM,IAAI5I,MAAM,CAAC,WAAW,EAAE4I,eAAeD,QAAQ;AACvD;AAEA;;CAEC,GACD,SAASE,YAAYC,SAAmB;IACtC,MAAM,IAAI9I,MAAM;AAClB;AACA7B,iBAAiB4K,CAAC,GAAGF;AAErB,kGAAkG;AAClG1K,iBAAiB6K,CAAC,GAAGC;AAMrB,SAASpD,uBAAuBqD,OAAiB;IAC/C,+DAA+D;IAC/D5K,OAAOQ,cAAc,CAACoK,SAAS,QAAQ;QACrCzJ,OAAO;IACT;AACF","ignoreList":[0]}},
+    {"offset": {"line": 514, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 747, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1766, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js
new file mode 100644
index 00000000000000..95f0812215abca
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js
@@ -0,0 +1,9 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js",
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js [test] (ecmascript)", ((__turbopack_context__, module, exports) => {
+
+console.log('worker.js');
+self.postMessage('hello');
+}),
+]);
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js.map
new file mode 100644
index 00000000000000..e6653f5c1703b0
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js.map
@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 3, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js"],"sourcesContent":["console.log('worker.js')\nself.postMessage('hello')\n"],"names":["console","log","self","postMessage"],"mappings":"AAAAA,QAAQC,GAAG,CAAC;AACZC,KAAKC,WAAW,CAAC"}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js
new file mode 100644
index 00000000000000..dc21694a21662c
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js
@@ -0,0 +1,1869 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([
+    "output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js",
+    {"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js [test] (ecmascript)"]}
+]);
+(() => {
+if (!Array.isArray(globalThis.TURBOPACK)) {
+    return;
+}
+
+const CHUNK_BASE_PATH = "";
+const RELATIVE_ROOT_PATH = "../../../../../../..";
+const RUNTIME_PUBLIC_PATH = "";
+const CHUNK_SUFFIX = "";
+/**
+ * This file contains runtime types and functions that are shared between all
+ * TurboPack ECMAScript runtimes.
+ *
+ * It will be prepended to the runtime code of each runtime.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
+const REEXPORTED_OBJECTS = new WeakMap();
+/**
+ * Constructs the `__turbopack_context__` object for a module.
+ */ function Context(module, exports) {
+    this.m = module;
+    // We need to store this here instead of accessing it from the module object to:
+    // 1. Make it available to factories directly, since we rewrite `this` to
+    //    `__turbopack_context__.e` in CJS modules.
+    // 2. Support async modules which rewrite `module.exports` to a promise, so we
+    //    can still access the original exports object from functions like
+    //    `esmExport`
+    // Ideally we could find a new approach for async modules and drop this property altogether.
+    this.e = exports;
+}
+const contextPrototype = Context.prototype;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+function defineProp(obj, name, options) {
+    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
+}
+function getOverwrittenModule(moduleCache, id) {
+    let module = moduleCache[id];
+    if (!module) {
+        // This is invoked when a module is merged into another module, thus it wasn't invoked via
+        // instantiateModule and the cache entry wasn't created yet.
+        module = createModuleObject(id);
+        moduleCache[id] = module;
+    }
+    return module;
+}
+/**
+ * Creates the module object. Only done here to ensure all module objects have the same shape.
+ */ function createModuleObject(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined
+    };
+}
+const BindingTag_Value = 0;
+/**
+ * Adds the getters to the exports object.
+ */ function esm(exports, bindings) {
+    defineProp(exports, '__esModule', {
+        value: true
+    });
+    if (toStringTag) defineProp(exports, toStringTag, {
+        value: 'Module'
+    });
+    let i = 0;
+    while(i < bindings.length){
+        const propName = bindings[i++];
+        const tagOrFunction = bindings[i++];
+        if (typeof tagOrFunction === 'number') {
+            if (tagOrFunction === BindingTag_Value) {
+                defineProp(exports, propName, {
+                    value: bindings[i++],
+                    enumerable: true,
+                    writable: false
+                });
+            } else {
+                throw new Error(`unexpected tag: ${tagOrFunction}`);
+            }
+        } else {
+            const getterFn = tagOrFunction;
+            if (typeof bindings[i] === 'function') {
+                const setterFn = bindings[i++];
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    set: setterFn,
+                    enumerable: true
+                });
+            } else {
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    enumerable: true
+                });
+            }
+        }
+    }
+    Object.seal(exports);
+}
+/**
+ * Makes the module an ESM with exports
+ */ function esmExport(bindings, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    module.namespaceObject = exports;
+    esm(exports, bindings);
+}
+contextPrototype.s = esmExport;
+function ensureDynamicExports(module, exports) {
+    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
+    if (!reexportedObjects) {
+        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
+        module.exports = module.namespaceObject = new Proxy(exports, {
+            get (target, prop) {
+                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
+                    return Reflect.get(target, prop);
+                }
+                for (const obj of reexportedObjects){
+                    const value = Reflect.get(obj, prop);
+                    if (value !== undefined) return value;
+                }
+                return undefined;
+            },
+            ownKeys (target) {
+                const keys = Reflect.ownKeys(target);
+                for (const obj of reexportedObjects){
+                    for (const key of Reflect.ownKeys(obj)){
+                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
+                    }
+                }
+                return keys;
+            }
+        });
+    }
+    return reexportedObjects;
+}
+/**
+ * Dynamically exports properties from an object
+ */ function dynamicExport(object, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    const reexportedObjects = ensureDynamicExports(module, exports);
+    if (typeof object === 'object' && object !== null) {
+        reexportedObjects.push(object);
+    }
+}
+contextPrototype.j = dynamicExport;
+function exportValue(value, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = value;
+}
+contextPrototype.v = exportValue;
+function exportNamespace(namespace, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = module.namespaceObject = namespace;
+}
+contextPrototype.n = exportNamespace;
+function createGetter(obj, key) {
+    return ()=>obj[key];
+}
+/**
+ * @returns prototype of the object
+ */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
+    null,
+    getProto({}),
+    getProto([]),
+    getProto(getProto)
+];
+/**
+ * @param raw
+ * @param ns
+ * @param allowExportDefault
+ *   * `false`: will have the raw module as default export
+ *   * `true`: will have the default property as default export
+ */ function interopEsm(raw, ns, allowExportDefault) {
+    const bindings = [];
+    let defaultLocation = -1;
+    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
+        for (const key of Object.getOwnPropertyNames(current)){
+            bindings.push(key, createGetter(raw, key));
+            if (defaultLocation === -1 && key === 'default') {
+                defaultLocation = bindings.length - 1;
+            }
+        }
+    }
+    // this is not really correct
+    // we should set the `default` getter if the imported module is a `.cjs file`
+    if (!(allowExportDefault && defaultLocation >= 0)) {
+        // Replace the binding with one for the namespace itself in order to preserve iteration order.
+        if (defaultLocation >= 0) {
+            // Replace the getter with the value
+            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
+        } else {
+            bindings.push('default', BindingTag_Value, raw);
+        }
+    }
+    esm(ns, bindings);
+    return ns;
+}
+function createNS(raw) {
+    if (typeof raw === 'function') {
+        return function(...args) {
+            return raw.apply(this, args);
+        };
+    } else {
+        return Object.create(null);
+    }
+}
+function esmImport(id) {
+    const module = getOrInstantiateModuleFromParent(id, this.m);
+    // any ES module has to have `module.namespaceObject` defined.
+    if (module.namespaceObject) return module.namespaceObject;
+    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
+    const raw = module.exports;
+    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
+}
+contextPrototype.i = esmImport;
+function asyncLoader(moduleId) {
+    const loader = this.r(moduleId);
+    return loader(esmImport.bind(this));
+}
+contextPrototype.A = asyncLoader;
+// Add a simple runtime require so that environments without one can still pass
+// `typeof require` CommonJS checks so that exports are correctly registered.
+const runtimeRequire = // @ts-ignore
+typeof require === 'function' ? require : function require1() {
+    throw new Error('Unexpected use of runtime require');
+};
+contextPrototype.t = runtimeRequire;
+function commonJsRequire(id) {
+    return getOrInstantiateModuleFromParent(id, this.m).exports;
+}
+contextPrototype.r = commonJsRequire;
+/**
+ * Remove fragments and query parameters since they are never part of the context map keys
+ *
+ * This matches how we parse patterns at resolving time.  Arguably we should only do this for
+ * strings passed to `import` but the resolve does it for `import` and `require` and so we do
+ * here as well.
+ */ function parseRequest(request) {
+    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    const hashIndex = request.indexOf('#');
+    if (hashIndex !== -1) {
+        request = request.substring(0, hashIndex);
+    }
+    const queryIndex = request.indexOf('?');
+    if (queryIndex !== -1) {
+        request = request.substring(0, queryIndex);
+    }
+    return request;
+}
+/**
+ * `require.context` and require/import expression runtime.
+ */ function moduleContext(map) {
+    function moduleContext(id) {
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].module();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    }
+    moduleContext.keys = ()=>{
+        return Object.keys(map);
+    };
+    moduleContext.resolve = (id)=>{
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].id();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    };
+    moduleContext.import = async (id)=>{
+        return await moduleContext(id);
+    };
+    return moduleContext;
+}
+contextPrototype.f = moduleContext;
+/**
+ * Returns the path of a chunk defined by its data.
+ */ function getChunkPath(chunkData) {
+    return typeof chunkData === 'string' ? chunkData : chunkData.path;
+}
+function isPromise(maybePromise) {
+    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
+}
+function isAsyncModuleExt(obj) {
+    return turbopackQueues in obj;
+}
+function createPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        reject = rej;
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
+// The CompressedModuleFactories format is
+// - 1 or more module ids
+// - a module factory function
+// So walking this is a little complex but the flat structure is also fast to
+// traverse, we can use `typeof` operators to distinguish the two cases.
+function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
+    let i = offset;
+    while(i < chunkModules.length){
+        let moduleId = chunkModules[i];
+        let end = i + 1;
+        // Find our factory function
+        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
+            end++;
+        }
+        if (end === chunkModules.length) {
+            throw new Error('malformed chunk format, expected a factory function');
+        }
+        // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already
+        // present we know all the additional ids are also present, so we don't need to check.
+        if (!moduleFactories.has(moduleId)) {
+            const moduleFactoryFn = chunkModules[end];
+            applyModuleFactoryName(moduleFactoryFn);
+            newModuleId?.(moduleId);
+            for(; i < end; i++){
+                moduleId = chunkModules[i];
+                moduleFactories.set(moduleId, moduleFactoryFn);
+            }
+        }
+        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
+    }
+}
+// everything below is adapted from webpack
+// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
+const turbopackQueues = Symbol('turbopack queues');
+const turbopackExports = Symbol('turbopack exports');
+const turbopackError = Symbol('turbopack error');
+function resolveQueue(queue) {
+    if (queue && queue.status !== 1) {
+        queue.status = 1;
+        queue.forEach((fn)=>fn.queueCount--);
+        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
+    }
+}
+function wrapDeps(deps) {
+    return deps.map((dep)=>{
+        if (dep !== null && typeof dep === 'object') {
+            if (isAsyncModuleExt(dep)) return dep;
+            if (isPromise(dep)) {
+                const queue = Object.assign([], {
+                    status: 0
+                });
+                const obj = {
+                    [turbopackExports]: {},
+                    [turbopackQueues]: (fn)=>fn(queue)
+                };
+                dep.then((res)=>{
+                    obj[turbopackExports] = res;
+                    resolveQueue(queue);
+                }, (err)=>{
+                    obj[turbopackError] = err;
+                    resolveQueue(queue);
+                });
+                return obj;
+            }
+        }
+        return {
+            [turbopackExports]: dep,
+            [turbopackQueues]: ()=>{}
+        };
+    });
+}
+function asyncModule(body, hasAwait) {
+    const module = this.m;
+    const queue = hasAwait ? Object.assign([], {
+        status: -1
+    }) : undefined;
+    const depQueues = new Set();
+    const { resolve, reject, promise: rawPromise } = createPromise();
+    const promise = Object.assign(rawPromise, {
+        [turbopackExports]: module.exports,
+        [turbopackQueues]: (fn)=>{
+            queue && fn(queue);
+            depQueues.forEach(fn);
+            promise['catch'](()=>{});
+        }
+    });
+    const attributes = {
+        get () {
+            return promise;
+        },
+        set (v) {
+            // Calling `esmExport` leads to this.
+            if (v !== promise) {
+                promise[turbopackExports] = v;
+            }
+        }
+    };
+    Object.defineProperty(module, 'exports', attributes);
+    Object.defineProperty(module, 'namespaceObject', attributes);
+    function handleAsyncDependencies(deps) {
+        const currentDeps = wrapDeps(deps);
+        const getResult = ()=>currentDeps.map((d)=>{
+                if (d[turbopackError]) throw d[turbopackError];
+                return d[turbopackExports];
+            });
+        const { promise, resolve } = createPromise();
+        const fn = Object.assign(()=>resolve(getResult), {
+            queueCount: 0
+        });
+        function fnQueue(q) {
+            if (q !== queue && !depQueues.has(q)) {
+                depQueues.add(q);
+                if (q && q.status === 0) {
+                    fn.queueCount++;
+                    q.push(fn);
+                }
+            }
+        }
+        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
+        return fn.queueCount ? promise : getResult();
+    }
+    function asyncResult(err) {
+        if (err) {
+            reject(promise[turbopackError] = err);
+        } else {
+            resolve(promise[turbopackExports]);
+        }
+        resolveQueue(queue);
+    }
+    body(handleAsyncDependencies, asyncResult);
+    if (queue && queue.status === -1) {
+        queue.status = 0;
+    }
+}
+contextPrototype.a = asyncModule;
+/**
+ * A pseudo "fake" URL object to resolve to its relative path.
+ *
+ * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
+ * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
+ * hydration mismatch.
+ *
+ * This is based on webpack's existing implementation:
+ * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
+ */ const relativeURL = function relativeURL(inputUrl) {
+    const realUrl = new URL(inputUrl, 'x:/');
+    const values = {};
+    for(const key in realUrl)values[key] = realUrl[key];
+    values.href = inputUrl;
+    values.pathname = inputUrl.replace(/[?#].*/, '');
+    values.origin = values.protocol = '';
+    values.toString = values.toJSON = (..._args)=>inputUrl;
+    for(const key in values)Object.defineProperty(this, key, {
+        enumerable: true,
+        configurable: true,
+        value: values[key]
+    });
+};
+relativeURL.prototype = URL.prototype;
+contextPrototype.U = relativeURL;
+/**
+ * Utility function to ensure all variants of an enum are handled.
+ */ function invariant(never, computeMessage) {
+    throw new Error(`Invariant: ${computeMessage(never)}`);
+}
+/**
+ * A stub function to make `require` available but non-functional in ESM.
+ */ function requireStub(_moduleId) {
+    throw new Error('dynamic usage of require is not supported');
+}
+contextPrototype.z = requireStub;
+// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
+contextPrototype.g = globalThis;
+function applyModuleFactoryName(factory) {
+    // Give the module factory a nice name to improve stack traces.
+    Object.defineProperty(factory, 'name', {
+        value: 'module evaluation'
+    });
+}
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *browser* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
+/// <reference path="../../../shared/runtime-utils.ts" />
+// Used in WebWorkers to tell the runtime about the chunk suffix
+const browserContextPrototype = Context.prototype;
+var SourceType = /*#__PURE__*/ function(SourceType) {
+    /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
+    /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */ SourceType[SourceType["Parent"] = 1] = "Parent";
+    /**
+   * The module was instantiated because it was included in a chunk's hot module
+   * update.
+   * SourceData is an array of ModuleIds or undefined.
+   */ SourceType[SourceType["Update"] = 2] = "Update";
+    return SourceType;
+}(SourceType || {});
+const moduleFactories = new Map();
+contextPrototype.M = moduleFactories;
+const availableModules = new Map();
+const availableModuleChunks = new Map();
+function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
+    let instantiationReason;
+    switch(sourceType){
+        case 0:
+            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
+            break;
+        case 1:
+            instantiationReason = `because it was required from module ${sourceData}`;
+            break;
+        case 2:
+            instantiationReason = 'because of an HMR update';
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
+}
+function loadChunk(chunkData) {
+    return loadChunkInternal(1, this.m.id, chunkData);
+}
+browserContextPrototype.l = loadChunk;
+function loadInitialChunk(chunkPath, chunkData) {
+    return loadChunkInternal(0, chunkPath, chunkData);
+}
+async function loadChunkInternal(sourceType, sourceData, chunkData) {
+    if (typeof chunkData === 'string') {
+        return loadChunkPath(sourceType, sourceData, chunkData);
+    }
+    const includedList = chunkData.included || [];
+    const modulesPromises = includedList.map((included)=>{
+        if (moduleFactories.has(included)) return true;
+        return availableModules.get(included);
+    });
+    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
+        // When all included items are already loaded or loading, we can skip loading ourselves
+        await Promise.all(modulesPromises);
+        return;
+    }
+    const includedModuleChunksList = chunkData.moduleChunks || [];
+    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
+        // TODO(alexkirsz) Do we need this check?
+        // if (moduleFactories[included]) return true;
+        return availableModuleChunks.get(included);
+    }).filter((p)=>p);
+    let promise;
+    if (moduleChunksPromises.length > 0) {
+        // Some module chunks are already loaded or loading.
+        if (moduleChunksPromises.length === includedModuleChunksList.length) {
+            // When all included module chunks are already loaded or loading, we can skip loading ourselves
+            await Promise.all(moduleChunksPromises);
+            return;
+        }
+        const moduleChunksToLoad = new Set();
+        for (const moduleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(moduleChunk)) {
+                moduleChunksToLoad.add(moduleChunk);
+            }
+        }
+        for (const moduleChunkToLoad of moduleChunksToLoad){
+            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
+            availableModuleChunks.set(moduleChunkToLoad, promise);
+            moduleChunksPromises.push(promise);
+        }
+        promise = Promise.all(moduleChunksPromises);
+    } else {
+        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
+        // Mark all included module chunks as loading if they are not already loaded or loading.
+        for (const includedModuleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(includedModuleChunk)) {
+                availableModuleChunks.set(includedModuleChunk, promise);
+            }
+        }
+    }
+    for (const included of includedList){
+        if (!availableModules.has(included)) {
+            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
+            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
+            availableModules.set(included, promise);
+        }
+    }
+    await promise;
+}
+const loadedChunk = Promise.resolve(undefined);
+const instrumentedBackendLoadChunks = new WeakMap();
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrl(chunkUrl) {
+    return loadChunkByUrlInternal(1, this.m.id, chunkUrl);
+}
+browserContextPrototype.L = loadChunkByUrl;
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
+    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
+    let entry = instrumentedBackendLoadChunks.get(thenable);
+    if (entry === undefined) {
+        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
+        entry = thenable.then(resolve).catch((cause)=>{
+            let loadReason;
+            switch(sourceType){
+                case 0:
+                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
+                    break;
+                case 1:
+                    loadReason = `from module ${sourceData}`;
+                    break;
+                case 2:
+                    loadReason = 'from an HMR update';
+                    break;
+                default:
+                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+            }
+            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
+                cause
+            } : undefined);
+            error.name = 'ChunkLoadError';
+            throw error;
+        });
+        instrumentedBackendLoadChunks.set(thenable, entry);
+    }
+    return entry;
+}
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkPath(sourceType, sourceData, chunkPath) {
+    const url = getChunkRelativeUrl(chunkPath);
+    return loadChunkByUrlInternal(sourceType, sourceData, url);
+}
+/**
+ * Returns an absolute url to an asset.
+ */ function resolvePathFromModule(moduleId) {
+    const exported = this.r(moduleId);
+    return exported?.default ?? exported;
+}
+browserContextPrototype.R = resolvePathFromModule;
+/**
+ * no-op for browser
+ * @param modulePath
+ */ function resolveAbsolutePath(modulePath) {
+    return `/ROOT/${modulePath ?? ''}`;
+}
+browserContextPrototype.P = resolveAbsolutePath;
+/**
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    const url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    const params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map((chunk)=>getChunkRelativeUrl(chunk))
+    };
+    const paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
+}
+browserContextPrototype.b = getWorkerURL;
+/**
+ * Instantiates a runtime module.
+ */ function instantiateRuntimeModule(moduleId, chunkPath) {
+    return instantiateModule(moduleId, 0, chunkPath);
+}
+/**
+ * Returns the URL relative to the origin where a chunk can be fetched from.
+ */ function getChunkRelativeUrl(chunkPath) {
+    return `${CHUNK_BASE_PATH}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${CHUNK_SUFFIX}`;
+}
+function getPathFromScript(chunkScript) {
+    if (typeof chunkScript === 'string') {
+        return chunkScript;
+    }
+    const chunkUrl = typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' ? TURBOPACK_NEXT_CHUNK_URLS.pop() : chunkScript.getAttribute('src');
+    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
+    const path = src.startsWith(CHUNK_BASE_PATH) ? src.slice(CHUNK_BASE_PATH.length) : src;
+    return path;
+}
+const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.
+ */ function isJs(chunkUrlOrPath) {
+    return regexJsUrl.test(chunkUrlOrPath);
+}
+const regexCssUrl = /\.css(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.
+ */ function isCss(chunkUrl) {
+    return regexCssUrl.test(chunkUrl);
+}
+function loadWebAssembly(chunkPath, edgeModule, importsObj) {
+    return BACKEND.loadWebAssembly(1, this.m.id, chunkPath, edgeModule, importsObj);
+}
+contextPrototype.w = loadWebAssembly;
+function loadWebAssemblyModule(chunkPath, edgeModule) {
+    return BACKEND.loadWebAssemblyModule(1, this.m.id, chunkPath, edgeModule);
+}
+contextPrototype.u = loadWebAssemblyModule;
+/// <reference path="./dev-globals.d.ts" />
+/// <reference path="./dev-protocol.d.ts" />
+/// <reference path="./dev-extensions.ts" />
+const devContextPrototype = Context.prototype;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *development* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ const devModuleCache = Object.create(null);
+devContextPrototype.c = devModuleCache;
+class UpdateApplyError extends Error {
+    name = 'UpdateApplyError';
+    dependencyChain;
+    constructor(message, dependencyChain){
+        super(message);
+        this.dependencyChain = dependencyChain;
+    }
+}
+/**
+ * Module IDs that are instantiated as part of the runtime of a chunk.
+ */ const runtimeModules = new Set();
+/**
+ * Map from module ID to the chunks that contain this module.
+ *
+ * In HMR, we need to keep track of which modules are contained in which so
+ * chunks. This is so we don't eagerly dispose of a module when it is removed
+ * from chunk A, but still exists in chunk B.
+ */ const moduleChunksMap = new Map();
+/**
+ * Map from a chunk path to all modules it contains.
+ */ const chunkModulesMap = new Map();
+/**
+ * Chunk lists that contain a runtime. When these chunk lists receive an update
+ * that can't be reconciled with the current state of the page, we need to
+ * reload the runtime entirely.
+ */ const runtimeChunkLists = new Set();
+/**
+ * Map from a chunk list to the chunk paths it contains.
+ */ const chunkListChunksMap = new Map();
+/**
+ * Map from a chunk path to the chunk lists it belongs to.
+ */ const chunkChunkListsMap = new Map();
+/**
+ * Maps module IDs to persisted data between executions of their hot module
+ * implementation (`hot.data`).
+ */ const moduleHotData = new Map();
+/**
+ * Maps module instances to their hot module state.
+ */ const moduleHotState = new Map();
+/**
+ * Modules that call `module.hot.invalidate()` (while being updated).
+ */ const queuedInvalidatedModules = new Set();
+/**
+ * Gets or instantiates a runtime module.
+ */ // @ts-ignore
+function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
+    const module = devModuleCache[moduleId];
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        return module;
+    }
+    // @ts-ignore
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */ // @ts-ignore Defined in `runtime-utils.ts`
+const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
+    if (!sourceModule.hot.active) {
+        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
+    }
+    const module = devModuleCache[id];
+    if (sourceModule.children.indexOf(id) === -1) {
+        sourceModule.children.push(id);
+    }
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        if (module.parents.indexOf(sourceModule.id) === -1) {
+            module.parents.push(sourceModule.id);
+        }
+        return module;
+    }
+    return instantiateModule(id, SourceType.Parent, sourceModule.id);
+};
+function DevContext(module, exports, refresh) {
+    Context.call(this, module, exports);
+    this.k = refresh;
+}
+DevContext.prototype = Context.prototype;
+function instantiateModule(moduleId, sourceType, sourceData) {
+    // We are in development, this is always a string.
+    let id = moduleId;
+    const moduleFactory = moduleFactories.get(id);
+    if (typeof moduleFactory !== 'function') {
+        // This can happen if modules incorrectly handle HMR disposes/updates,
+        // e.g. when they keep a `setTimeout` around which still executes old code
+        // and contains e.g. a `require("something")` call.
+        throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData) + ' It might have been deleted in an HMR update.');
+    }
+    const hotData = moduleHotData.get(id);
+    const { hot, hotState } = createModuleHot(id, hotData);
+    let parents;
+    switch(sourceType){
+        case SourceType.Runtime:
+            runtimeModules.add(id);
+            parents = [];
+            break;
+        case SourceType.Parent:
+            // No need to add this module as a child of the parent module here, this
+            // has already been taken care of in `getOrInstantiateModuleFromParent`.
+            parents = [
+                sourceData
+            ];
+            break;
+        case SourceType.Update:
+            parents = sourceData || [];
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    const module = createModuleObject(id);
+    const exports = module.exports;
+    module.parents = parents;
+    module.children = [];
+    module.hot = hot;
+    devModuleCache[id] = module;
+    moduleHotState.set(module, hotState);
+    // NOTE(alexkirsz) This can fail when the module encounters a runtime error.
+    try {
+        runModuleExecutionHooks(module, (refresh)=>{
+            const context = new DevContext(module, exports, refresh);
+            moduleFactory(context, module, exports);
+        });
+    } catch (error) {
+        module.error = error;
+        throw error;
+    }
+    if (module.namespaceObject && module.exports !== module.namespaceObject) {
+        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+        interopEsm(module.exports, module.namespaceObject);
+    }
+    return module;
+}
+const DUMMY_REFRESH_CONTEXT = {
+    register: (_type, _id)=>{},
+    signature: ()=>(_type)=>{},
+    registerExports: (_module, _helpers)=>{}
+};
+/**
+ * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
+ * Next.js' React Refresh runtime hooks into to add module context to the
+ * refresh registry.
+ */ function runModuleExecutionHooks(module, executeModule) {
+    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
+        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
+        try {
+            executeModule({
+                register: globalThis.$RefreshReg$,
+                signature: globalThis.$RefreshSig$,
+                registerExports: registerExportsAndSetupBoundaryForReactRefresh
+            });
+        } finally{
+            // Always cleanup the intercept, even if module execution failed.
+            cleanupReactRefreshIntercept();
+        }
+    } else {
+        // If the react refresh hooks are not installed we need to bind dummy functions.
+        // This is expected when running in a Web Worker.  It is also common in some of
+        // our test environments.
+        executeModule(DUMMY_REFRESH_CONTEXT);
+    }
+}
+/**
+ * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+ */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
+    const currentExports = module.exports;
+    const prevExports = module.hot.data.prevExports ?? null;
+    helpers.registerExportsForReactRefresh(currentExports, module.id);
+    // A module can be accepted automatically based on its exports, e.g. when
+    // it is a Refresh Boundary.
+    if (helpers.isReactRefreshBoundary(currentExports)) {
+        // Save the previous exports on update, so we can compare the boundary
+        // signatures.
+        module.hot.dispose((data)=>{
+            data.prevExports = currentExports;
+        });
+        // Unconditionally accept an update to this module, we'll check if it's
+        // still a Refresh Boundary later.
+        module.hot.accept();
+        // This field is set when the previous version of this module was a
+        // Refresh Boundary, letting us know we need to check for invalidation or
+        // enqueue an update.
+        if (prevExports !== null) {
+            // A boundary can become ineligible if its exports are incompatible
+            // with the previous exports.
+            //
+            // For example, if you add/remove/change exports, we'll want to
+            // re-execute the importing modules, and force those components to
+            // re-render. Similarly, if you convert a class component to a
+            // function, we want to invalidate the boundary.
+            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
+                module.hot.invalidate();
+            } else {
+                helpers.scheduleUpdate();
+            }
+        }
+    } else {
+        // Since we just executed the code for the module, it's possible that the
+        // new exports made it ineligible for being a boundary.
+        // We only care about the case when we were _previously_ a boundary,
+        // because we already accepted this update (accidental side effect).
+        const isNoLongerABoundary = prevExports !== null;
+        if (isNoLongerABoundary) {
+            module.hot.invalidate();
+        }
+    }
+}
+function formatDependencyChain(dependencyChain) {
+    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
+}
+function computeOutdatedModules(added, modified) {
+    const newModuleFactories = new Map();
+    for (const [moduleId, entry] of added){
+        if (entry != null) {
+            newModuleFactories.set(moduleId, _eval(entry));
+        }
+    }
+    const outdatedModules = computedInvalidatedModules(modified.keys());
+    for (const [moduleId, entry] of modified){
+        newModuleFactories.set(moduleId, _eval(entry));
+    }
+    return {
+        outdatedModules,
+        newModuleFactories
+    };
+}
+function computedInvalidatedModules(invalidated) {
+    const outdatedModules = new Set();
+    for (const moduleId of invalidated){
+        const effect = getAffectedModuleEffects(moduleId);
+        switch(effect.type){
+            case 'unaccepted':
+                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'self-declined':
+                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'accepted':
+                for (const outdatedModuleId of effect.outdatedModules){
+                    outdatedModules.add(outdatedModuleId);
+                }
+                break;
+            // TODO(alexkirsz) Dependencies: handle dependencies effects.
+            default:
+                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
+        }
+    }
+    return outdatedModules;
+}
+function computeOutdatedSelfAcceptedModules(outdatedModules) {
+    const outdatedSelfAcceptedModules = [];
+    for (const moduleId of outdatedModules){
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (module && hotState.selfAccepted && !hotState.selfInvalidated) {
+            outdatedSelfAcceptedModules.push({
+                moduleId,
+                errorHandler: hotState.selfAccepted
+            });
+        }
+    }
+    return outdatedSelfAcceptedModules;
+}
+/**
+ * Adds, deletes, and moves modules between chunks. This must happen before the
+ * dispose phase as it needs to know which modules were removed from all chunks,
+ * which we can only compute *after* taking care of added and moved modules.
+ */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
+    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
+        for (const moduleId of addedModuleIds){
+            addModuleToChunk(moduleId, chunkPath);
+        }
+    }
+    const disposedModules = new Set();
+    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
+        for (const moduleId of addedModuleIds){
+            if (removeModuleFromChunk(moduleId, chunkPath)) {
+                disposedModules.add(moduleId);
+            }
+        }
+    }
+    return {
+        disposedModules
+    };
+}
+function disposePhase(outdatedModules, disposedModules) {
+    for (const moduleId of outdatedModules){
+        disposeModule(moduleId, 'replace');
+    }
+    for (const moduleId of disposedModules){
+        disposeModule(moduleId, 'clear');
+    }
+    // Removing modules from the module cache is a separate step.
+    // We also want to keep track of previous parents of the outdated modules.
+    const outdatedModuleParents = new Map();
+    for (const moduleId of outdatedModules){
+        const oldModule = devModuleCache[moduleId];
+        outdatedModuleParents.set(moduleId, oldModule?.parents);
+        delete devModuleCache[moduleId];
+    }
+    // TODO(alexkirsz) Dependencies: remove outdated dependency from module
+    // children.
+    return {
+        outdatedModuleParents
+    };
+}
+/**
+ * Disposes of an instance of a module.
+ *
+ * Returns the persistent hot data that should be kept for the next module
+ * instance.
+ *
+ * NOTE: mode = "replace" will not remove modules from the devModuleCache
+ * This must be done in a separate step afterwards.
+ * This is important because all modules need to be disposed to update the
+ * parent/child relationships before they are actually removed from the devModuleCache.
+ * If this was done in this method, the following disposeModule calls won't find
+ * the module from the module id in the cache.
+ */ function disposeModule(moduleId, mode) {
+    const module = devModuleCache[moduleId];
+    if (!module) {
+        return;
+    }
+    const hotState = moduleHotState.get(module);
+    const data = {};
+    // Run the `hot.dispose` handler, if any, passing in the persistent
+    // `hot.data` object.
+    for (const disposeHandler of hotState.disposeHandlers){
+        disposeHandler(data);
+    }
+    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
+    // module is still importing other modules.
+    module.hot.active = false;
+    moduleHotState.delete(module);
+    // TODO(alexkirsz) Dependencies: delete the module from outdated deps.
+    // Remove the disposed module from its children's parent list.
+    // It will be added back once the module re-instantiates and imports its
+    // children again.
+    for (const childId of module.children){
+        const child = devModuleCache[childId];
+        if (!child) {
+            continue;
+        }
+        const idx = child.parents.indexOf(module.id);
+        if (idx >= 0) {
+            child.parents.splice(idx, 1);
+        }
+    }
+    switch(mode){
+        case 'clear':
+            delete devModuleCache[module.id];
+            moduleHotData.delete(module.id);
+            break;
+        case 'replace':
+            moduleHotData.set(module.id, data);
+            break;
+        default:
+            invariant(mode, (mode)=>`invalid mode: ${mode}`);
+    }
+}
+function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError) {
+    // Update module factories.
+    for (const [moduleId, factory] of newModuleFactories.entries()){
+        applyModuleFactoryName(factory);
+        moduleFactories.set(moduleId, factory);
+    }
+    // TODO(alexkirsz) Run new runtime entries here.
+    // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.
+    // Re-instantiate all outdated self-accepted modules.
+    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
+        try {
+            instantiateModule(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
+        } catch (err) {
+            if (typeof errorHandler === 'function') {
+                try {
+                    errorHandler(err, {
+                        moduleId,
+                        module: devModuleCache[moduleId]
+                    });
+                } catch (err2) {
+                    reportError(err2);
+                    reportError(err);
+                }
+            } else {
+                reportError(err);
+            }
+        }
+    }
+}
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+    }
+}
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+        }
+    }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+            }
+        }
+    }
+}
+function applyEcmascriptMergedUpdate(update) {
+    const { entries = {}, chunks = {} } = update;
+    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks);
+    const { outdatedModules, newModuleFactories } = computeOutdatedModules(added, modified);
+    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
+    applyInternal(outdatedModules, disposedModules, newModuleFactories);
+}
+function applyInvalidatedModules(outdatedModules) {
+    if (queuedInvalidatedModules.size > 0) {
+        computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId)=>{
+            outdatedModules.add(moduleId);
+        });
+        queuedInvalidatedModules.clear();
+    }
+    return outdatedModules;
+}
+function applyInternal(outdatedModules, disposedModules, newModuleFactories) {
+    outdatedModules = applyInvalidatedModules(outdatedModules);
+    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
+    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules);
+    // we want to continue on error and only throw the error after we tried applying all updates
+    let error;
+    function reportError(err) {
+        if (!error) error = err;
+    }
+    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError);
+    if (error) {
+        throw error;
+    }
+    if (queuedInvalidatedModules.size > 0) {
+        applyInternal(new Set(), [], new Map());
+    }
+}
+function computeChangedModules(entries, updates) {
+    const chunksAdded = new Map();
+    const chunksDeleted = new Map();
+    const added = new Map();
+    const modified = new Map();
+    const deleted = new Set();
+    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
+        switch(mergedChunkUpdate.type){
+            case 'added':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.modules);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    break;
+                }
+            case 'deleted':
+                {
+                    // We could also use `mergedChunkUpdate.modules` here.
+                    const updateDeleted = new Set(chunkModulesMap.get(chunkPath));
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            case 'partial':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.added);
+                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            default:
+                invariant(mergedChunkUpdate, (mergedChunkUpdate)=>`Unknown merged chunk update type: ${mergedChunkUpdate.type}`);
+        }
+    }
+    // If a module was added from one chunk and deleted from another in the same update,
+    // consider it to be modified, as it means the module was moved from one chunk to another
+    // AND has new code in a single update.
+    for (const moduleId of added.keys()){
+        if (deleted.has(moduleId)) {
+            added.delete(moduleId);
+            deleted.delete(moduleId);
+        }
+    }
+    for (const [moduleId, entry] of Object.entries(entries)){
+        // Modules that haven't been added to any chunk but have new code are considered
+        // to be modified.
+        // This needs to be under the previous loop, as we need it to get rid of modules
+        // that were added and deleted in the same update.
+        if (!added.has(moduleId)) {
+            modified.set(moduleId, entry);
+        }
+    }
+    return {
+        added,
+        deleted,
+        modified,
+        chunksAdded,
+        chunksDeleted
+    };
+}
+function getAffectedModuleEffects(moduleId) {
+    const outdatedModules = new Set();
+    const queue = [
+        {
+            moduleId,
+            dependencyChain: []
+        }
+    ];
+    let nextItem;
+    while(nextItem = queue.shift()){
+        const { moduleId, dependencyChain } = nextItem;
+        if (moduleId != null) {
+            if (outdatedModules.has(moduleId)) {
+                continue;
+            }
+            outdatedModules.add(moduleId);
+        }
+        // We've arrived at the runtime of the chunk, which means that nothing
+        // else above can accept this update.
+        if (moduleId === undefined) {
+            return {
+                type: 'unaccepted',
+                dependencyChain
+            };
+        }
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (// The module is not in the cache. Since this is a "modified" update,
+        // it means that the module was never instantiated before.
+        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
+            continue;
+        }
+        if (hotState.selfDeclined) {
+            return {
+                type: 'self-declined',
+                dependencyChain,
+                moduleId
+            };
+        }
+        if (runtimeModules.has(moduleId)) {
+            queue.push({
+                moduleId: undefined,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+            continue;
+        }
+        for (const parentId of module.parents){
+            const parent = devModuleCache[parentId];
+            if (!parent) {
+                continue;
+            }
+            // TODO(alexkirsz) Dependencies: check accepted and declined
+            // dependencies here.
+            queue.push({
+                moduleId: parentId,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+        }
+    }
+    return {
+        type: 'accepted',
+        moduleId,
+        outdatedModules
+    };
+}
+function handleApply(chunkListPath, update) {
+    switch(update.type){
+        case 'partial':
+            {
+                // This indicates that the update is can be applied to the current state of the application.
+                applyUpdate(update.instruction);
+                break;
+            }
+        case 'restart':
+            {
+                // This indicates that there is no way to apply the update to the
+                // current state of the application, and that the application must be
+                // restarted.
+                DEV_BACKEND.restart();
+                break;
+            }
+        case 'notFound':
+            {
+                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
+                // or the page itself was deleted.
+                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
+                // If it is a runtime chunk list, we restart the application.
+                if (runtimeChunkLists.has(chunkListPath)) {
+                    DEV_BACKEND.restart();
+                } else {
+                    disposeChunkList(chunkListPath);
+                }
+                break;
+            }
+        default:
+            throw new Error(`Unknown update type: ${update.type}`);
+    }
+}
+function createModuleHot(moduleId, hotData) {
+    const hotState = {
+        selfAccepted: false,
+        selfDeclined: false,
+        selfInvalidated: false,
+        disposeHandlers: []
+    };
+    const hot = {
+        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
+        // decide whether to warn whenever an HMR-disposed module required other
+        // modules. We might want to remove it.
+        active: true,
+        data: hotData ?? {},
+        // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.
+        accept: (modules, _callback, _errorHandler)=>{
+            if (modules === undefined) {
+                hotState.selfAccepted = true;
+            } else if (typeof modules === 'function') {
+                hotState.selfAccepted = modules;
+            } else {
+                throw new Error('unsupported `accept` signature');
+            }
+        },
+        decline: (dep)=>{
+            if (dep === undefined) {
+                hotState.selfDeclined = true;
+            } else {
+                throw new Error('unsupported `decline` signature');
+            }
+        },
+        dispose: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        addDisposeHandler: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        removeDisposeHandler: (callback)=>{
+            const idx = hotState.disposeHandlers.indexOf(callback);
+            if (idx >= 0) {
+                hotState.disposeHandlers.splice(idx, 1);
+            }
+        },
+        invalidate: ()=>{
+            hotState.selfInvalidated = true;
+            queuedInvalidatedModules.add(moduleId);
+        },
+        // NOTE(alexkirsz) This is part of the management API, which we don't
+        // implement, but the Next.js React Refresh runtime uses this to decide
+        // whether to schedule an update.
+        status: ()=>'idle',
+        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
+        addStatusHandler: (_handler)=>{},
+        removeStatusHandler: (_handler)=>{},
+        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
+        // want the webpack code paths to ever update (the turbopack paths handle
+        // this already).
+        check: ()=>Promise.resolve(null)
+    };
+    return {
+        hot,
+        hotState
+    };
+}
+/**
+ * Removes a module from a chunk.
+ * Returns `true` if there are no remaining chunks including this module.
+ */ function removeModuleFromChunk(moduleId, chunkPath) {
+    const moduleChunks = moduleChunksMap.get(moduleId);
+    moduleChunks.delete(chunkPath);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    chunkModules.delete(moduleId);
+    const noRemainingModules = chunkModules.size === 0;
+    if (noRemainingModules) {
+        chunkModulesMap.delete(chunkPath);
+    }
+    const noRemainingChunks = moduleChunks.size === 0;
+    if (noRemainingChunks) {
+        moduleChunksMap.delete(moduleId);
+    }
+    return noRemainingChunks;
+}
+/**
+ * Disposes of a chunk list and its corresponding exclusive chunks.
+ */ function disposeChunkList(chunkListPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (chunkPaths == null) {
+        return false;
+    }
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
+            disposeChunk(chunkPath);
+        }
+    }
+    // We must also dispose of the chunk list's chunk itself to ensure it may
+    // be reloaded properly in the future.
+    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
+    DEV_BACKEND.unloadChunk?.(chunkListUrl);
+    return true;
+}
+/**
+ * Disposes of a chunk and its corresponding exclusive modules.
+ *
+ * @returns Whether the chunk was disposed of.
+ */ function disposeChunk(chunkPath) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    // This should happen whether the chunk has any modules in it or not.
+    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
+    DEV_BACKEND.unloadChunk?.(chunkUrl);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    if (chunkModules == null) {
+        return false;
+    }
+    chunkModules.delete(chunkPath);
+    for (const moduleId of chunkModules){
+        const moduleChunks = moduleChunksMap.get(moduleId);
+        moduleChunks.delete(chunkPath);
+        const noRemainingChunks = moduleChunks.size === 0;
+        if (noRemainingChunks) {
+            moduleChunksMap.delete(moduleId);
+            disposeModule(moduleId, 'clear');
+            availableModules.delete(moduleId);
+        }
+    }
+    return true;
+}
+/**
+ * Adds a module to a chunk.
+ */ function addModuleToChunk(moduleId, chunkPath) {
+    let moduleChunks = moduleChunksMap.get(moduleId);
+    if (!moduleChunks) {
+        moduleChunks = new Set([
+            chunkPath
+        ]);
+        moduleChunksMap.set(moduleId, moduleChunks);
+    } else {
+        moduleChunks.add(chunkPath);
+    }
+    let chunkModules = chunkModulesMap.get(chunkPath);
+    if (!chunkModules) {
+        chunkModules = new Set([
+            moduleId
+        ]);
+        chunkModulesMap.set(chunkPath, chunkModules);
+    } else {
+        chunkModules.add(moduleId);
+    }
+}
+/**
+ * Marks a chunk list as a runtime chunk list. There can be more than one
+ * runtime chunk list. For instance, integration tests can have multiple chunk
+ * groups loaded at runtime, each with its own chunk list.
+ */ function markChunkListAsRuntime(chunkListPath) {
+    runtimeChunkLists.add(chunkListPath);
+}
+function registerChunk(registration) {
+    const chunkPath = getPathFromScript(registration[0]);
+    let runtimeParams;
+    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
+    if (registration.length === 2) {
+        runtimeParams = registration[1];
+    } else {
+        runtimeParams = undefined;
+        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
+    }
+    return BACKEND.registerChunk(chunkPath, runtimeParams);
+}
+/**
+ * Subscribes to chunk list updates from the update server and applies them.
+ */ function registerChunkList(chunkList) {
+    const chunkListScript = chunkList.script;
+    const chunkListPath = getPathFromScript(chunkListScript);
+    // The "chunk" is also registered to finish the loading in the backend
+    BACKEND.registerChunk(chunkListPath);
+    globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath)
+    ]);
+    // Adding chunks to chunk lists and vice versa.
+    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
+    if (chunkList.source === 'entry') {
+        markChunkListAsRuntime(chunkListPath);
+    }
+}
+globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
+/**
+ * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
+ *
+ * It will be appended to the base runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
+/// <reference path="../../../shared/runtime-types.d.ts" />
+function getChunkSuffixFromScriptSrc() {
+    // TURBOPACK_CHUNK_SUFFIX is set in web workers
+    return (self.TURBOPACK_CHUNK_SUFFIX ?? document?.currentScript?.getAttribute?.('src')?.replace(/^(.*(?=\?)|^.*$)/, '')) || '';
+}
+let BACKEND;
+/**
+ * Maps chunk paths to the corresponding resolver.
+ */ const chunkResolvers = new Map();
+(()=>{
+    BACKEND = {
+        async registerChunk (chunkPath, params) {
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            const resolver = getOrCreateResolver(chunkUrl);
+            resolver.resolve();
+            if (params == null) {
+                return;
+            }
+            for (const otherChunkData of params.otherChunks){
+                const otherChunkPath = getChunkPath(otherChunkData);
+                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
+                // Chunk might have started loading, so we want to avoid triggering another load.
+                getOrCreateResolver(otherChunkUrl);
+            }
+            // This waits for chunks to be loaded, but also marks included items as available.
+            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
+            if (params.runtimeModuleIds.length > 0) {
+                for (const moduleId of params.runtimeModuleIds){
+                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
+                }
+            }
+        },
+        /**
+     * Loads the given chunk, and returns a promise that resolves once the chunk
+     * has been loaded.
+     */ loadChunkCached (sourceType, chunkUrl) {
+            return doLoadChunk(sourceType, chunkUrl);
+        },
+        async loadWebAssembly (_sourceType, _sourceData, wasmChunkPath, _edgeModule, importsObj) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            const { instance } = await WebAssembly.instantiateStreaming(req, importsObj);
+            return instance.exports;
+        },
+        async loadWebAssemblyModule (_sourceType, _sourceData, wasmChunkPath, _edgeModule) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            return await WebAssembly.compileStreaming(req);
+        }
+    };
+    function getOrCreateResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        return resolver;
+    }
+    /**
+   * Loads the given chunk, and returns a promise that resolves once the chunk
+   * has been loaded.
+   */ function doLoadChunk(sourceType, chunkUrl) {
+        const resolver = getOrCreateResolver(chunkUrl);
+        if (resolver.loadingStarted) {
+            return resolver.promise;
+        }
+        if (sourceType === SourceType.Runtime) {
+            // We don't need to load chunks references from runtime code, as they're already
+            // present in the DOM.
+            resolver.loadingStarted = true;
+            if (isCss(chunkUrl)) {
+                // CSS chunks do not register themselves, and as such must be marked as
+                // loaded instantly.
+                resolver.resolve();
+            }
+            // We need to wait for JS chunks to register themselves within `registerChunk`
+            // before we can start instantiating runtime modules, hence the absence of
+            // `resolver.resolve()` in this branch.
+            return resolver.promise;
+        }
+        if (typeof importScripts === 'function') {
+            // We're in a web worker
+            if (isCss(chunkUrl)) {
+            // ignore
+            } else if (isJs(chunkUrl)) {
+                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
+                importScripts(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
+            }
+        } else {
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length > 0) {
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolver.resolve();
+                } else {
+                    const link = document.createElement('link');
+                    link.rel = 'stylesheet';
+                    link.href = chunkUrl;
+                    link.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    link.onload = ()=>{
+                        // CSS chunks do not register themselves, and as such must be marked as
+                        // loaded instantly.
+                        resolver.resolve();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(link);
+                }
+            } else if (isJs(chunkUrl)) {
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    // There is this edge where the script already failed loading, but we
+                    // can't detect that. The Promise will never resolve in this case.
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            resolver.reject();
+                        });
+                    }
+                } else {
+                    const script = document.createElement('script');
+                    script.src = chunkUrl;
+                    // We'll only mark the chunk as loaded once the script has been executed,
+                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
+                    // this branch.
+                    script.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(script);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        }
+        resolver.loadingStarted = true;
+        return resolver.promise;
+    }
+    function fetchWebAssembly(wasmChunkPath) {
+        return fetch(getChunkRelativeUrl(wasmChunkPath));
+    }
+})();
+/**
+ * This file contains the runtime code specific to the Turbopack development
+ * ECMAScript DOM runtime.
+ *
+ * It will be appended to the base development runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
+/// <reference path="../base/dev-base.ts" />
+/// <reference path="./runtime-backend-dom.ts" />
+/// <reference path="../../../shared/require-type.d.ts" />
+let DEV_BACKEND;
+(()=>{
+    DEV_BACKEND = {
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${chunkUrl}"],link[href^="${chunkUrl}?"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
+                }
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        },
+        reloadChunk (chunkUrl) {
+            return new Promise((resolve, reject)=>{
+                if (!isCss(chunkUrl)) {
+                    reject(new Error('The DOM backend can only reload CSS chunks'));
+                    return;
+                }
+                const decodedChunkUrl = decodeURI(chunkUrl);
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length === 0) {
+                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
+                    return;
+                }
+                const link = document.createElement('link');
+                link.rel = 'stylesheet';
+                if (navigator.userAgent.includes('Firefox')) {
+                    // Firefox won't reload CSS files that were previously loaded on the current page,
+                    // we need to add a query param to make sure CSS is actually reloaded from the server.
+                    //
+                    // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
+                    //
+                    // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag
+                    // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726
+                    link.href = `${chunkUrl}?ts=${Date.now()}`;
+                } else {
+                    link.href = chunkUrl;
+                }
+                link.onerror = ()=>{
+                    reject();
+                };
+                link.onload = ()=>{
+                    // First load the new CSS, then remove the old ones. This prevents visible
+                    // flickering that would happen in-between removing the previous CSS and
+                    // loading the new one.
+                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolve();
+                };
+                // Make sure to insert the new CSS right after the previous one, so that
+                // its precedence is higher.
+                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
+            });
+        },
+        restart: ()=>self.location.reload()
+    };
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
+    }
+})();
+function _eval({ code, url, map }) {
+    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX)}`;
+    if (map) {
+        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
+        // See https://stackoverflow.com/a/26603875
+        unescape(encodeURIComponent(map)))}`;
+    }
+    // eslint-disable-next-line no-eval
+    return eval(code);
+}
+const chunksToRegister = globalThis.TURBOPACK;
+globalThis.TURBOPACK = { push: registerChunk };
+chunksToRegister.forEach(registerChunk);
+const chunkListsToRegister = globalThis.TURBOPACK_CHUNK_LISTS || [];
+globalThis.TURBOPACK_CHUNK_LISTS = { push: registerChunkList };
+chunkListsToRegister.forEach(registerChunkList);
+})();
+
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_index_96b0ffc6.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js
new file mode 100644
index 00000000000000..12f2b4da8ef49f
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js
@@ -0,0 +1,1869 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([
+    "output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js",
+    {"otherChunks":["output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js [test] (ecmascript)"]}
+]);
+(() => {
+if (!Array.isArray(globalThis.TURBOPACK)) {
+    return;
+}
+
+const CHUNK_BASE_PATH = "";
+const RELATIVE_ROOT_PATH = "../../../../../../..";
+const RUNTIME_PUBLIC_PATH = "";
+const CHUNK_SUFFIX = "";
+/**
+ * This file contains runtime types and functions that are shared between all
+ * TurboPack ECMAScript runtimes.
+ *
+ * It will be prepended to the runtime code of each runtime.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
+const REEXPORTED_OBJECTS = new WeakMap();
+/**
+ * Constructs the `__turbopack_context__` object for a module.
+ */ function Context(module, exports) {
+    this.m = module;
+    // We need to store this here instead of accessing it from the module object to:
+    // 1. Make it available to factories directly, since we rewrite `this` to
+    //    `__turbopack_context__.e` in CJS modules.
+    // 2. Support async modules which rewrite `module.exports` to a promise, so we
+    //    can still access the original exports object from functions like
+    //    `esmExport`
+    // Ideally we could find a new approach for async modules and drop this property altogether.
+    this.e = exports;
+}
+const contextPrototype = Context.prototype;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+function defineProp(obj, name, options) {
+    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
+}
+function getOverwrittenModule(moduleCache, id) {
+    let module = moduleCache[id];
+    if (!module) {
+        // This is invoked when a module is merged into another module, thus it wasn't invoked via
+        // instantiateModule and the cache entry wasn't created yet.
+        module = createModuleObject(id);
+        moduleCache[id] = module;
+    }
+    return module;
+}
+/**
+ * Creates the module object. Only done here to ensure all module objects have the same shape.
+ */ function createModuleObject(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined
+    };
+}
+const BindingTag_Value = 0;
+/**
+ * Adds the getters to the exports object.
+ */ function esm(exports, bindings) {
+    defineProp(exports, '__esModule', {
+        value: true
+    });
+    if (toStringTag) defineProp(exports, toStringTag, {
+        value: 'Module'
+    });
+    let i = 0;
+    while(i < bindings.length){
+        const propName = bindings[i++];
+        const tagOrFunction = bindings[i++];
+        if (typeof tagOrFunction === 'number') {
+            if (tagOrFunction === BindingTag_Value) {
+                defineProp(exports, propName, {
+                    value: bindings[i++],
+                    enumerable: true,
+                    writable: false
+                });
+            } else {
+                throw new Error(`unexpected tag: ${tagOrFunction}`);
+            }
+        } else {
+            const getterFn = tagOrFunction;
+            if (typeof bindings[i] === 'function') {
+                const setterFn = bindings[i++];
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    set: setterFn,
+                    enumerable: true
+                });
+            } else {
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    enumerable: true
+                });
+            }
+        }
+    }
+    Object.seal(exports);
+}
+/**
+ * Makes the module an ESM with exports
+ */ function esmExport(bindings, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    module.namespaceObject = exports;
+    esm(exports, bindings);
+}
+contextPrototype.s = esmExport;
+function ensureDynamicExports(module, exports) {
+    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
+    if (!reexportedObjects) {
+        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
+        module.exports = module.namespaceObject = new Proxy(exports, {
+            get (target, prop) {
+                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
+                    return Reflect.get(target, prop);
+                }
+                for (const obj of reexportedObjects){
+                    const value = Reflect.get(obj, prop);
+                    if (value !== undefined) return value;
+                }
+                return undefined;
+            },
+            ownKeys (target) {
+                const keys = Reflect.ownKeys(target);
+                for (const obj of reexportedObjects){
+                    for (const key of Reflect.ownKeys(obj)){
+                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
+                    }
+                }
+                return keys;
+            }
+        });
+    }
+    return reexportedObjects;
+}
+/**
+ * Dynamically exports properties from an object
+ */ function dynamicExport(object, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    const reexportedObjects = ensureDynamicExports(module, exports);
+    if (typeof object === 'object' && object !== null) {
+        reexportedObjects.push(object);
+    }
+}
+contextPrototype.j = dynamicExport;
+function exportValue(value, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = value;
+}
+contextPrototype.v = exportValue;
+function exportNamespace(namespace, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = module.namespaceObject = namespace;
+}
+contextPrototype.n = exportNamespace;
+function createGetter(obj, key) {
+    return ()=>obj[key];
+}
+/**
+ * @returns prototype of the object
+ */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
+    null,
+    getProto({}),
+    getProto([]),
+    getProto(getProto)
+];
+/**
+ * @param raw
+ * @param ns
+ * @param allowExportDefault
+ *   * `false`: will have the raw module as default export
+ *   * `true`: will have the default property as default export
+ */ function interopEsm(raw, ns, allowExportDefault) {
+    const bindings = [];
+    let defaultLocation = -1;
+    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
+        for (const key of Object.getOwnPropertyNames(current)){
+            bindings.push(key, createGetter(raw, key));
+            if (defaultLocation === -1 && key === 'default') {
+                defaultLocation = bindings.length - 1;
+            }
+        }
+    }
+    // this is not really correct
+    // we should set the `default` getter if the imported module is a `.cjs file`
+    if (!(allowExportDefault && defaultLocation >= 0)) {
+        // Replace the binding with one for the namespace itself in order to preserve iteration order.
+        if (defaultLocation >= 0) {
+            // Replace the getter with the value
+            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
+        } else {
+            bindings.push('default', BindingTag_Value, raw);
+        }
+    }
+    esm(ns, bindings);
+    return ns;
+}
+function createNS(raw) {
+    if (typeof raw === 'function') {
+        return function(...args) {
+            return raw.apply(this, args);
+        };
+    } else {
+        return Object.create(null);
+    }
+}
+function esmImport(id) {
+    const module = getOrInstantiateModuleFromParent(id, this.m);
+    // any ES module has to have `module.namespaceObject` defined.
+    if (module.namespaceObject) return module.namespaceObject;
+    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
+    const raw = module.exports;
+    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
+}
+contextPrototype.i = esmImport;
+function asyncLoader(moduleId) {
+    const loader = this.r(moduleId);
+    return loader(esmImport.bind(this));
+}
+contextPrototype.A = asyncLoader;
+// Add a simple runtime require so that environments without one can still pass
+// `typeof require` CommonJS checks so that exports are correctly registered.
+const runtimeRequire = // @ts-ignore
+typeof require === 'function' ? require : function require1() {
+    throw new Error('Unexpected use of runtime require');
+};
+contextPrototype.t = runtimeRequire;
+function commonJsRequire(id) {
+    return getOrInstantiateModuleFromParent(id, this.m).exports;
+}
+contextPrototype.r = commonJsRequire;
+/**
+ * Remove fragments and query parameters since they are never part of the context map keys
+ *
+ * This matches how we parse patterns at resolving time.  Arguably we should only do this for
+ * strings passed to `import` but the resolve does it for `import` and `require` and so we do
+ * here as well.
+ */ function parseRequest(request) {
+    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    const hashIndex = request.indexOf('#');
+    if (hashIndex !== -1) {
+        request = request.substring(0, hashIndex);
+    }
+    const queryIndex = request.indexOf('?');
+    if (queryIndex !== -1) {
+        request = request.substring(0, queryIndex);
+    }
+    return request;
+}
+/**
+ * `require.context` and require/import expression runtime.
+ */ function moduleContext(map) {
+    function moduleContext(id) {
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].module();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    }
+    moduleContext.keys = ()=>{
+        return Object.keys(map);
+    };
+    moduleContext.resolve = (id)=>{
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].id();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    };
+    moduleContext.import = async (id)=>{
+        return await moduleContext(id);
+    };
+    return moduleContext;
+}
+contextPrototype.f = moduleContext;
+/**
+ * Returns the path of a chunk defined by its data.
+ */ function getChunkPath(chunkData) {
+    return typeof chunkData === 'string' ? chunkData : chunkData.path;
+}
+function isPromise(maybePromise) {
+    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
+}
+function isAsyncModuleExt(obj) {
+    return turbopackQueues in obj;
+}
+function createPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        reject = rej;
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
+// The CompressedModuleFactories format is
+// - 1 or more module ids
+// - a module factory function
+// So walking this is a little complex but the flat structure is also fast to
+// traverse, we can use `typeof` operators to distinguish the two cases.
+function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
+    let i = offset;
+    while(i < chunkModules.length){
+        let moduleId = chunkModules[i];
+        let end = i + 1;
+        // Find our factory function
+        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
+            end++;
+        }
+        if (end === chunkModules.length) {
+            throw new Error('malformed chunk format, expected a factory function');
+        }
+        // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already
+        // present we know all the additional ids are also present, so we don't need to check.
+        if (!moduleFactories.has(moduleId)) {
+            const moduleFactoryFn = chunkModules[end];
+            applyModuleFactoryName(moduleFactoryFn);
+            newModuleId?.(moduleId);
+            for(; i < end; i++){
+                moduleId = chunkModules[i];
+                moduleFactories.set(moduleId, moduleFactoryFn);
+            }
+        }
+        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
+    }
+}
+// everything below is adapted from webpack
+// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
+const turbopackQueues = Symbol('turbopack queues');
+const turbopackExports = Symbol('turbopack exports');
+const turbopackError = Symbol('turbopack error');
+function resolveQueue(queue) {
+    if (queue && queue.status !== 1) {
+        queue.status = 1;
+        queue.forEach((fn)=>fn.queueCount--);
+        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
+    }
+}
+function wrapDeps(deps) {
+    return deps.map((dep)=>{
+        if (dep !== null && typeof dep === 'object') {
+            if (isAsyncModuleExt(dep)) return dep;
+            if (isPromise(dep)) {
+                const queue = Object.assign([], {
+                    status: 0
+                });
+                const obj = {
+                    [turbopackExports]: {},
+                    [turbopackQueues]: (fn)=>fn(queue)
+                };
+                dep.then((res)=>{
+                    obj[turbopackExports] = res;
+                    resolveQueue(queue);
+                }, (err)=>{
+                    obj[turbopackError] = err;
+                    resolveQueue(queue);
+                });
+                return obj;
+            }
+        }
+        return {
+            [turbopackExports]: dep,
+            [turbopackQueues]: ()=>{}
+        };
+    });
+}
+function asyncModule(body, hasAwait) {
+    const module = this.m;
+    const queue = hasAwait ? Object.assign([], {
+        status: -1
+    }) : undefined;
+    const depQueues = new Set();
+    const { resolve, reject, promise: rawPromise } = createPromise();
+    const promise = Object.assign(rawPromise, {
+        [turbopackExports]: module.exports,
+        [turbopackQueues]: (fn)=>{
+            queue && fn(queue);
+            depQueues.forEach(fn);
+            promise['catch'](()=>{});
+        }
+    });
+    const attributes = {
+        get () {
+            return promise;
+        },
+        set (v) {
+            // Calling `esmExport` leads to this.
+            if (v !== promise) {
+                promise[turbopackExports] = v;
+            }
+        }
+    };
+    Object.defineProperty(module, 'exports', attributes);
+    Object.defineProperty(module, 'namespaceObject', attributes);
+    function handleAsyncDependencies(deps) {
+        const currentDeps = wrapDeps(deps);
+        const getResult = ()=>currentDeps.map((d)=>{
+                if (d[turbopackError]) throw d[turbopackError];
+                return d[turbopackExports];
+            });
+        const { promise, resolve } = createPromise();
+        const fn = Object.assign(()=>resolve(getResult), {
+            queueCount: 0
+        });
+        function fnQueue(q) {
+            if (q !== queue && !depQueues.has(q)) {
+                depQueues.add(q);
+                if (q && q.status === 0) {
+                    fn.queueCount++;
+                    q.push(fn);
+                }
+            }
+        }
+        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
+        return fn.queueCount ? promise : getResult();
+    }
+    function asyncResult(err) {
+        if (err) {
+            reject(promise[turbopackError] = err);
+        } else {
+            resolve(promise[turbopackExports]);
+        }
+        resolveQueue(queue);
+    }
+    body(handleAsyncDependencies, asyncResult);
+    if (queue && queue.status === -1) {
+        queue.status = 0;
+    }
+}
+contextPrototype.a = asyncModule;
+/**
+ * A pseudo "fake" URL object to resolve to its relative path.
+ *
+ * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
+ * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
+ * hydration mismatch.
+ *
+ * This is based on webpack's existing implementation:
+ * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
+ */ const relativeURL = function relativeURL(inputUrl) {
+    const realUrl = new URL(inputUrl, 'x:/');
+    const values = {};
+    for(const key in realUrl)values[key] = realUrl[key];
+    values.href = inputUrl;
+    values.pathname = inputUrl.replace(/[?#].*/, '');
+    values.origin = values.protocol = '';
+    values.toString = values.toJSON = (..._args)=>inputUrl;
+    for(const key in values)Object.defineProperty(this, key, {
+        enumerable: true,
+        configurable: true,
+        value: values[key]
+    });
+};
+relativeURL.prototype = URL.prototype;
+contextPrototype.U = relativeURL;
+/**
+ * Utility function to ensure all variants of an enum are handled.
+ */ function invariant(never, computeMessage) {
+    throw new Error(`Invariant: ${computeMessage(never)}`);
+}
+/**
+ * A stub function to make `require` available but non-functional in ESM.
+ */ function requireStub(_moduleId) {
+    throw new Error('dynamic usage of require is not supported');
+}
+contextPrototype.z = requireStub;
+// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
+contextPrototype.g = globalThis;
+function applyModuleFactoryName(factory) {
+    // Give the module factory a nice name to improve stack traces.
+    Object.defineProperty(factory, 'name', {
+        value: 'module evaluation'
+    });
+}
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *browser* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
+/// <reference path="../../../shared/runtime-utils.ts" />
+// Used in WebWorkers to tell the runtime about the chunk suffix
+const browserContextPrototype = Context.prototype;
+var SourceType = /*#__PURE__*/ function(SourceType) {
+    /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
+    /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */ SourceType[SourceType["Parent"] = 1] = "Parent";
+    /**
+   * The module was instantiated because it was included in a chunk's hot module
+   * update.
+   * SourceData is an array of ModuleIds or undefined.
+   */ SourceType[SourceType["Update"] = 2] = "Update";
+    return SourceType;
+}(SourceType || {});
+const moduleFactories = new Map();
+contextPrototype.M = moduleFactories;
+const availableModules = new Map();
+const availableModuleChunks = new Map();
+function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
+    let instantiationReason;
+    switch(sourceType){
+        case 0:
+            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
+            break;
+        case 1:
+            instantiationReason = `because it was required from module ${sourceData}`;
+            break;
+        case 2:
+            instantiationReason = 'because of an HMR update';
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
+}
+function loadChunk(chunkData) {
+    return loadChunkInternal(1, this.m.id, chunkData);
+}
+browserContextPrototype.l = loadChunk;
+function loadInitialChunk(chunkPath, chunkData) {
+    return loadChunkInternal(0, chunkPath, chunkData);
+}
+async function loadChunkInternal(sourceType, sourceData, chunkData) {
+    if (typeof chunkData === 'string') {
+        return loadChunkPath(sourceType, sourceData, chunkData);
+    }
+    const includedList = chunkData.included || [];
+    const modulesPromises = includedList.map((included)=>{
+        if (moduleFactories.has(included)) return true;
+        return availableModules.get(included);
+    });
+    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
+        // When all included items are already loaded or loading, we can skip loading ourselves
+        await Promise.all(modulesPromises);
+        return;
+    }
+    const includedModuleChunksList = chunkData.moduleChunks || [];
+    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
+        // TODO(alexkirsz) Do we need this check?
+        // if (moduleFactories[included]) return true;
+        return availableModuleChunks.get(included);
+    }).filter((p)=>p);
+    let promise;
+    if (moduleChunksPromises.length > 0) {
+        // Some module chunks are already loaded or loading.
+        if (moduleChunksPromises.length === includedModuleChunksList.length) {
+            // When all included module chunks are already loaded or loading, we can skip loading ourselves
+            await Promise.all(moduleChunksPromises);
+            return;
+        }
+        const moduleChunksToLoad = new Set();
+        for (const moduleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(moduleChunk)) {
+                moduleChunksToLoad.add(moduleChunk);
+            }
+        }
+        for (const moduleChunkToLoad of moduleChunksToLoad){
+            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
+            availableModuleChunks.set(moduleChunkToLoad, promise);
+            moduleChunksPromises.push(promise);
+        }
+        promise = Promise.all(moduleChunksPromises);
+    } else {
+        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
+        // Mark all included module chunks as loading if they are not already loaded or loading.
+        for (const includedModuleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(includedModuleChunk)) {
+                availableModuleChunks.set(includedModuleChunk, promise);
+            }
+        }
+    }
+    for (const included of includedList){
+        if (!availableModules.has(included)) {
+            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
+            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
+            availableModules.set(included, promise);
+        }
+    }
+    await promise;
+}
+const loadedChunk = Promise.resolve(undefined);
+const instrumentedBackendLoadChunks = new WeakMap();
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrl(chunkUrl) {
+    return loadChunkByUrlInternal(1, this.m.id, chunkUrl);
+}
+browserContextPrototype.L = loadChunkByUrl;
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
+    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
+    let entry = instrumentedBackendLoadChunks.get(thenable);
+    if (entry === undefined) {
+        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
+        entry = thenable.then(resolve).catch((cause)=>{
+            let loadReason;
+            switch(sourceType){
+                case 0:
+                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
+                    break;
+                case 1:
+                    loadReason = `from module ${sourceData}`;
+                    break;
+                case 2:
+                    loadReason = 'from an HMR update';
+                    break;
+                default:
+                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+            }
+            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
+                cause
+            } : undefined);
+            error.name = 'ChunkLoadError';
+            throw error;
+        });
+        instrumentedBackendLoadChunks.set(thenable, entry);
+    }
+    return entry;
+}
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkPath(sourceType, sourceData, chunkPath) {
+    const url = getChunkRelativeUrl(chunkPath);
+    return loadChunkByUrlInternal(sourceType, sourceData, url);
+}
+/**
+ * Returns an absolute url to an asset.
+ */ function resolvePathFromModule(moduleId) {
+    const exported = this.r(moduleId);
+    return exported?.default ?? exported;
+}
+browserContextPrototype.R = resolvePathFromModule;
+/**
+ * no-op for browser
+ * @param modulePath
+ */ function resolveAbsolutePath(modulePath) {
+    return `/ROOT/${modulePath ?? ''}`;
+}
+browserContextPrototype.P = resolveAbsolutePath;
+/**
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    const url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    const params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map((chunk)=>getChunkRelativeUrl(chunk))
+    };
+    const paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
+}
+browserContextPrototype.b = getWorkerURL;
+/**
+ * Instantiates a runtime module.
+ */ function instantiateRuntimeModule(moduleId, chunkPath) {
+    return instantiateModule(moduleId, 0, chunkPath);
+}
+/**
+ * Returns the URL relative to the origin where a chunk can be fetched from.
+ */ function getChunkRelativeUrl(chunkPath) {
+    return `${CHUNK_BASE_PATH}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${CHUNK_SUFFIX}`;
+}
+function getPathFromScript(chunkScript) {
+    if (typeof chunkScript === 'string') {
+        return chunkScript;
+    }
+    const chunkUrl = typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' ? TURBOPACK_NEXT_CHUNK_URLS.pop() : chunkScript.getAttribute('src');
+    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
+    const path = src.startsWith(CHUNK_BASE_PATH) ? src.slice(CHUNK_BASE_PATH.length) : src;
+    return path;
+}
+const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.
+ */ function isJs(chunkUrlOrPath) {
+    return regexJsUrl.test(chunkUrlOrPath);
+}
+const regexCssUrl = /\.css(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.
+ */ function isCss(chunkUrl) {
+    return regexCssUrl.test(chunkUrl);
+}
+function loadWebAssembly(chunkPath, edgeModule, importsObj) {
+    return BACKEND.loadWebAssembly(1, this.m.id, chunkPath, edgeModule, importsObj);
+}
+contextPrototype.w = loadWebAssembly;
+function loadWebAssemblyModule(chunkPath, edgeModule) {
+    return BACKEND.loadWebAssemblyModule(1, this.m.id, chunkPath, edgeModule);
+}
+contextPrototype.u = loadWebAssemblyModule;
+/// <reference path="./dev-globals.d.ts" />
+/// <reference path="./dev-protocol.d.ts" />
+/// <reference path="./dev-extensions.ts" />
+const devContextPrototype = Context.prototype;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *development* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ const devModuleCache = Object.create(null);
+devContextPrototype.c = devModuleCache;
+class UpdateApplyError extends Error {
+    name = 'UpdateApplyError';
+    dependencyChain;
+    constructor(message, dependencyChain){
+        super(message);
+        this.dependencyChain = dependencyChain;
+    }
+}
+/**
+ * Module IDs that are instantiated as part of the runtime of a chunk.
+ */ const runtimeModules = new Set();
+/**
+ * Map from module ID to the chunks that contain this module.
+ *
+ * In HMR, we need to keep track of which modules are contained in which so
+ * chunks. This is so we don't eagerly dispose of a module when it is removed
+ * from chunk A, but still exists in chunk B.
+ */ const moduleChunksMap = new Map();
+/**
+ * Map from a chunk path to all modules it contains.
+ */ const chunkModulesMap = new Map();
+/**
+ * Chunk lists that contain a runtime. When these chunk lists receive an update
+ * that can't be reconciled with the current state of the page, we need to
+ * reload the runtime entirely.
+ */ const runtimeChunkLists = new Set();
+/**
+ * Map from a chunk list to the chunk paths it contains.
+ */ const chunkListChunksMap = new Map();
+/**
+ * Map from a chunk path to the chunk lists it belongs to.
+ */ const chunkChunkListsMap = new Map();
+/**
+ * Maps module IDs to persisted data between executions of their hot module
+ * implementation (`hot.data`).
+ */ const moduleHotData = new Map();
+/**
+ * Maps module instances to their hot module state.
+ */ const moduleHotState = new Map();
+/**
+ * Modules that call `module.hot.invalidate()` (while being updated).
+ */ const queuedInvalidatedModules = new Set();
+/**
+ * Gets or instantiates a runtime module.
+ */ // @ts-ignore
+function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
+    const module = devModuleCache[moduleId];
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        return module;
+    }
+    // @ts-ignore
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */ // @ts-ignore Defined in `runtime-utils.ts`
+const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
+    if (!sourceModule.hot.active) {
+        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
+    }
+    const module = devModuleCache[id];
+    if (sourceModule.children.indexOf(id) === -1) {
+        sourceModule.children.push(id);
+    }
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        if (module.parents.indexOf(sourceModule.id) === -1) {
+            module.parents.push(sourceModule.id);
+        }
+        return module;
+    }
+    return instantiateModule(id, SourceType.Parent, sourceModule.id);
+};
+function DevContext(module, exports, refresh) {
+    Context.call(this, module, exports);
+    this.k = refresh;
+}
+DevContext.prototype = Context.prototype;
+function instantiateModule(moduleId, sourceType, sourceData) {
+    // We are in development, this is always a string.
+    let id = moduleId;
+    const moduleFactory = moduleFactories.get(id);
+    if (typeof moduleFactory !== 'function') {
+        // This can happen if modules incorrectly handle HMR disposes/updates,
+        // e.g. when they keep a `setTimeout` around which still executes old code
+        // and contains e.g. a `require("something")` call.
+        throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData) + ' It might have been deleted in an HMR update.');
+    }
+    const hotData = moduleHotData.get(id);
+    const { hot, hotState } = createModuleHot(id, hotData);
+    let parents;
+    switch(sourceType){
+        case SourceType.Runtime:
+            runtimeModules.add(id);
+            parents = [];
+            break;
+        case SourceType.Parent:
+            // No need to add this module as a child of the parent module here, this
+            // has already been taken care of in `getOrInstantiateModuleFromParent`.
+            parents = [
+                sourceData
+            ];
+            break;
+        case SourceType.Update:
+            parents = sourceData || [];
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    const module = createModuleObject(id);
+    const exports = module.exports;
+    module.parents = parents;
+    module.children = [];
+    module.hot = hot;
+    devModuleCache[id] = module;
+    moduleHotState.set(module, hotState);
+    // NOTE(alexkirsz) This can fail when the module encounters a runtime error.
+    try {
+        runModuleExecutionHooks(module, (refresh)=>{
+            const context = new DevContext(module, exports, refresh);
+            moduleFactory(context, module, exports);
+        });
+    } catch (error) {
+        module.error = error;
+        throw error;
+    }
+    if (module.namespaceObject && module.exports !== module.namespaceObject) {
+        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+        interopEsm(module.exports, module.namespaceObject);
+    }
+    return module;
+}
+const DUMMY_REFRESH_CONTEXT = {
+    register: (_type, _id)=>{},
+    signature: ()=>(_type)=>{},
+    registerExports: (_module, _helpers)=>{}
+};
+/**
+ * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
+ * Next.js' React Refresh runtime hooks into to add module context to the
+ * refresh registry.
+ */ function runModuleExecutionHooks(module, executeModule) {
+    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
+        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
+        try {
+            executeModule({
+                register: globalThis.$RefreshReg$,
+                signature: globalThis.$RefreshSig$,
+                registerExports: registerExportsAndSetupBoundaryForReactRefresh
+            });
+        } finally{
+            // Always cleanup the intercept, even if module execution failed.
+            cleanupReactRefreshIntercept();
+        }
+    } else {
+        // If the react refresh hooks are not installed we need to bind dummy functions.
+        // This is expected when running in a Web Worker.  It is also common in some of
+        // our test environments.
+        executeModule(DUMMY_REFRESH_CONTEXT);
+    }
+}
+/**
+ * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+ */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
+    const currentExports = module.exports;
+    const prevExports = module.hot.data.prevExports ?? null;
+    helpers.registerExportsForReactRefresh(currentExports, module.id);
+    // A module can be accepted automatically based on its exports, e.g. when
+    // it is a Refresh Boundary.
+    if (helpers.isReactRefreshBoundary(currentExports)) {
+        // Save the previous exports on update, so we can compare the boundary
+        // signatures.
+        module.hot.dispose((data)=>{
+            data.prevExports = currentExports;
+        });
+        // Unconditionally accept an update to this module, we'll check if it's
+        // still a Refresh Boundary later.
+        module.hot.accept();
+        // This field is set when the previous version of this module was a
+        // Refresh Boundary, letting us know we need to check for invalidation or
+        // enqueue an update.
+        if (prevExports !== null) {
+            // A boundary can become ineligible if its exports are incompatible
+            // with the previous exports.
+            //
+            // For example, if you add/remove/change exports, we'll want to
+            // re-execute the importing modules, and force those components to
+            // re-render. Similarly, if you convert a class component to a
+            // function, we want to invalidate the boundary.
+            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
+                module.hot.invalidate();
+            } else {
+                helpers.scheduleUpdate();
+            }
+        }
+    } else {
+        // Since we just executed the code for the module, it's possible that the
+        // new exports made it ineligible for being a boundary.
+        // We only care about the case when we were _previously_ a boundary,
+        // because we already accepted this update (accidental side effect).
+        const isNoLongerABoundary = prevExports !== null;
+        if (isNoLongerABoundary) {
+            module.hot.invalidate();
+        }
+    }
+}
+function formatDependencyChain(dependencyChain) {
+    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
+}
+function computeOutdatedModules(added, modified) {
+    const newModuleFactories = new Map();
+    for (const [moduleId, entry] of added){
+        if (entry != null) {
+            newModuleFactories.set(moduleId, _eval(entry));
+        }
+    }
+    const outdatedModules = computedInvalidatedModules(modified.keys());
+    for (const [moduleId, entry] of modified){
+        newModuleFactories.set(moduleId, _eval(entry));
+    }
+    return {
+        outdatedModules,
+        newModuleFactories
+    };
+}
+function computedInvalidatedModules(invalidated) {
+    const outdatedModules = new Set();
+    for (const moduleId of invalidated){
+        const effect = getAffectedModuleEffects(moduleId);
+        switch(effect.type){
+            case 'unaccepted':
+                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'self-declined':
+                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'accepted':
+                for (const outdatedModuleId of effect.outdatedModules){
+                    outdatedModules.add(outdatedModuleId);
+                }
+                break;
+            // TODO(alexkirsz) Dependencies: handle dependencies effects.
+            default:
+                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
+        }
+    }
+    return outdatedModules;
+}
+function computeOutdatedSelfAcceptedModules(outdatedModules) {
+    const outdatedSelfAcceptedModules = [];
+    for (const moduleId of outdatedModules){
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (module && hotState.selfAccepted && !hotState.selfInvalidated) {
+            outdatedSelfAcceptedModules.push({
+                moduleId,
+                errorHandler: hotState.selfAccepted
+            });
+        }
+    }
+    return outdatedSelfAcceptedModules;
+}
+/**
+ * Adds, deletes, and moves modules between chunks. This must happen before the
+ * dispose phase as it needs to know which modules were removed from all chunks,
+ * which we can only compute *after* taking care of added and moved modules.
+ */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
+    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
+        for (const moduleId of addedModuleIds){
+            addModuleToChunk(moduleId, chunkPath);
+        }
+    }
+    const disposedModules = new Set();
+    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
+        for (const moduleId of addedModuleIds){
+            if (removeModuleFromChunk(moduleId, chunkPath)) {
+                disposedModules.add(moduleId);
+            }
+        }
+    }
+    return {
+        disposedModules
+    };
+}
+function disposePhase(outdatedModules, disposedModules) {
+    for (const moduleId of outdatedModules){
+        disposeModule(moduleId, 'replace');
+    }
+    for (const moduleId of disposedModules){
+        disposeModule(moduleId, 'clear');
+    }
+    // Removing modules from the module cache is a separate step.
+    // We also want to keep track of previous parents of the outdated modules.
+    const outdatedModuleParents = new Map();
+    for (const moduleId of outdatedModules){
+        const oldModule = devModuleCache[moduleId];
+        outdatedModuleParents.set(moduleId, oldModule?.parents);
+        delete devModuleCache[moduleId];
+    }
+    // TODO(alexkirsz) Dependencies: remove outdated dependency from module
+    // children.
+    return {
+        outdatedModuleParents
+    };
+}
+/**
+ * Disposes of an instance of a module.
+ *
+ * Returns the persistent hot data that should be kept for the next module
+ * instance.
+ *
+ * NOTE: mode = "replace" will not remove modules from the devModuleCache
+ * This must be done in a separate step afterwards.
+ * This is important because all modules need to be disposed to update the
+ * parent/child relationships before they are actually removed from the devModuleCache.
+ * If this was done in this method, the following disposeModule calls won't find
+ * the module from the module id in the cache.
+ */ function disposeModule(moduleId, mode) {
+    const module = devModuleCache[moduleId];
+    if (!module) {
+        return;
+    }
+    const hotState = moduleHotState.get(module);
+    const data = {};
+    // Run the `hot.dispose` handler, if any, passing in the persistent
+    // `hot.data` object.
+    for (const disposeHandler of hotState.disposeHandlers){
+        disposeHandler(data);
+    }
+    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
+    // module is still importing other modules.
+    module.hot.active = false;
+    moduleHotState.delete(module);
+    // TODO(alexkirsz) Dependencies: delete the module from outdated deps.
+    // Remove the disposed module from its children's parent list.
+    // It will be added back once the module re-instantiates and imports its
+    // children again.
+    for (const childId of module.children){
+        const child = devModuleCache[childId];
+        if (!child) {
+            continue;
+        }
+        const idx = child.parents.indexOf(module.id);
+        if (idx >= 0) {
+            child.parents.splice(idx, 1);
+        }
+    }
+    switch(mode){
+        case 'clear':
+            delete devModuleCache[module.id];
+            moduleHotData.delete(module.id);
+            break;
+        case 'replace':
+            moduleHotData.set(module.id, data);
+            break;
+        default:
+            invariant(mode, (mode)=>`invalid mode: ${mode}`);
+    }
+}
+function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError) {
+    // Update module factories.
+    for (const [moduleId, factory] of newModuleFactories.entries()){
+        applyModuleFactoryName(factory);
+        moduleFactories.set(moduleId, factory);
+    }
+    // TODO(alexkirsz) Run new runtime entries here.
+    // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.
+    // Re-instantiate all outdated self-accepted modules.
+    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
+        try {
+            instantiateModule(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
+        } catch (err) {
+            if (typeof errorHandler === 'function') {
+                try {
+                    errorHandler(err, {
+                        moduleId,
+                        module: devModuleCache[moduleId]
+                    });
+                } catch (err2) {
+                    reportError(err2);
+                    reportError(err);
+                }
+            } else {
+                reportError(err);
+            }
+        }
+    }
+}
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+    }
+}
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+        }
+    }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+            }
+        }
+    }
+}
+function applyEcmascriptMergedUpdate(update) {
+    const { entries = {}, chunks = {} } = update;
+    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks);
+    const { outdatedModules, newModuleFactories } = computeOutdatedModules(added, modified);
+    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
+    applyInternal(outdatedModules, disposedModules, newModuleFactories);
+}
+function applyInvalidatedModules(outdatedModules) {
+    if (queuedInvalidatedModules.size > 0) {
+        computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId)=>{
+            outdatedModules.add(moduleId);
+        });
+        queuedInvalidatedModules.clear();
+    }
+    return outdatedModules;
+}
+function applyInternal(outdatedModules, disposedModules, newModuleFactories) {
+    outdatedModules = applyInvalidatedModules(outdatedModules);
+    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
+    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules);
+    // we want to continue on error and only throw the error after we tried applying all updates
+    let error;
+    function reportError(err) {
+        if (!error) error = err;
+    }
+    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError);
+    if (error) {
+        throw error;
+    }
+    if (queuedInvalidatedModules.size > 0) {
+        applyInternal(new Set(), [], new Map());
+    }
+}
+function computeChangedModules(entries, updates) {
+    const chunksAdded = new Map();
+    const chunksDeleted = new Map();
+    const added = new Map();
+    const modified = new Map();
+    const deleted = new Set();
+    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
+        switch(mergedChunkUpdate.type){
+            case 'added':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.modules);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    break;
+                }
+            case 'deleted':
+                {
+                    // We could also use `mergedChunkUpdate.modules` here.
+                    const updateDeleted = new Set(chunkModulesMap.get(chunkPath));
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            case 'partial':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.added);
+                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            default:
+                invariant(mergedChunkUpdate, (mergedChunkUpdate)=>`Unknown merged chunk update type: ${mergedChunkUpdate.type}`);
+        }
+    }
+    // If a module was added from one chunk and deleted from another in the same update,
+    // consider it to be modified, as it means the module was moved from one chunk to another
+    // AND has new code in a single update.
+    for (const moduleId of added.keys()){
+        if (deleted.has(moduleId)) {
+            added.delete(moduleId);
+            deleted.delete(moduleId);
+        }
+    }
+    for (const [moduleId, entry] of Object.entries(entries)){
+        // Modules that haven't been added to any chunk but have new code are considered
+        // to be modified.
+        // This needs to be under the previous loop, as we need it to get rid of modules
+        // that were added and deleted in the same update.
+        if (!added.has(moduleId)) {
+            modified.set(moduleId, entry);
+        }
+    }
+    return {
+        added,
+        deleted,
+        modified,
+        chunksAdded,
+        chunksDeleted
+    };
+}
+function getAffectedModuleEffects(moduleId) {
+    const outdatedModules = new Set();
+    const queue = [
+        {
+            moduleId,
+            dependencyChain: []
+        }
+    ];
+    let nextItem;
+    while(nextItem = queue.shift()){
+        const { moduleId, dependencyChain } = nextItem;
+        if (moduleId != null) {
+            if (outdatedModules.has(moduleId)) {
+                continue;
+            }
+            outdatedModules.add(moduleId);
+        }
+        // We've arrived at the runtime of the chunk, which means that nothing
+        // else above can accept this update.
+        if (moduleId === undefined) {
+            return {
+                type: 'unaccepted',
+                dependencyChain
+            };
+        }
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (// The module is not in the cache. Since this is a "modified" update,
+        // it means that the module was never instantiated before.
+        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
+            continue;
+        }
+        if (hotState.selfDeclined) {
+            return {
+                type: 'self-declined',
+                dependencyChain,
+                moduleId
+            };
+        }
+        if (runtimeModules.has(moduleId)) {
+            queue.push({
+                moduleId: undefined,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+            continue;
+        }
+        for (const parentId of module.parents){
+            const parent = devModuleCache[parentId];
+            if (!parent) {
+                continue;
+            }
+            // TODO(alexkirsz) Dependencies: check accepted and declined
+            // dependencies here.
+            queue.push({
+                moduleId: parentId,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+        }
+    }
+    return {
+        type: 'accepted',
+        moduleId,
+        outdatedModules
+    };
+}
+function handleApply(chunkListPath, update) {
+    switch(update.type){
+        case 'partial':
+            {
+                // This indicates that the update is can be applied to the current state of the application.
+                applyUpdate(update.instruction);
+                break;
+            }
+        case 'restart':
+            {
+                // This indicates that there is no way to apply the update to the
+                // current state of the application, and that the application must be
+                // restarted.
+                DEV_BACKEND.restart();
+                break;
+            }
+        case 'notFound':
+            {
+                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
+                // or the page itself was deleted.
+                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
+                // If it is a runtime chunk list, we restart the application.
+                if (runtimeChunkLists.has(chunkListPath)) {
+                    DEV_BACKEND.restart();
+                } else {
+                    disposeChunkList(chunkListPath);
+                }
+                break;
+            }
+        default:
+            throw new Error(`Unknown update type: ${update.type}`);
+    }
+}
+function createModuleHot(moduleId, hotData) {
+    const hotState = {
+        selfAccepted: false,
+        selfDeclined: false,
+        selfInvalidated: false,
+        disposeHandlers: []
+    };
+    const hot = {
+        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
+        // decide whether to warn whenever an HMR-disposed module required other
+        // modules. We might want to remove it.
+        active: true,
+        data: hotData ?? {},
+        // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.
+        accept: (modules, _callback, _errorHandler)=>{
+            if (modules === undefined) {
+                hotState.selfAccepted = true;
+            } else if (typeof modules === 'function') {
+                hotState.selfAccepted = modules;
+            } else {
+                throw new Error('unsupported `accept` signature');
+            }
+        },
+        decline: (dep)=>{
+            if (dep === undefined) {
+                hotState.selfDeclined = true;
+            } else {
+                throw new Error('unsupported `decline` signature');
+            }
+        },
+        dispose: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        addDisposeHandler: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        removeDisposeHandler: (callback)=>{
+            const idx = hotState.disposeHandlers.indexOf(callback);
+            if (idx >= 0) {
+                hotState.disposeHandlers.splice(idx, 1);
+            }
+        },
+        invalidate: ()=>{
+            hotState.selfInvalidated = true;
+            queuedInvalidatedModules.add(moduleId);
+        },
+        // NOTE(alexkirsz) This is part of the management API, which we don't
+        // implement, but the Next.js React Refresh runtime uses this to decide
+        // whether to schedule an update.
+        status: ()=>'idle',
+        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
+        addStatusHandler: (_handler)=>{},
+        removeStatusHandler: (_handler)=>{},
+        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
+        // want the webpack code paths to ever update (the turbopack paths handle
+        // this already).
+        check: ()=>Promise.resolve(null)
+    };
+    return {
+        hot,
+        hotState
+    };
+}
+/**
+ * Removes a module from a chunk.
+ * Returns `true` if there are no remaining chunks including this module.
+ */ function removeModuleFromChunk(moduleId, chunkPath) {
+    const moduleChunks = moduleChunksMap.get(moduleId);
+    moduleChunks.delete(chunkPath);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    chunkModules.delete(moduleId);
+    const noRemainingModules = chunkModules.size === 0;
+    if (noRemainingModules) {
+        chunkModulesMap.delete(chunkPath);
+    }
+    const noRemainingChunks = moduleChunks.size === 0;
+    if (noRemainingChunks) {
+        moduleChunksMap.delete(moduleId);
+    }
+    return noRemainingChunks;
+}
+/**
+ * Disposes of a chunk list and its corresponding exclusive chunks.
+ */ function disposeChunkList(chunkListPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (chunkPaths == null) {
+        return false;
+    }
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
+            disposeChunk(chunkPath);
+        }
+    }
+    // We must also dispose of the chunk list's chunk itself to ensure it may
+    // be reloaded properly in the future.
+    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
+    DEV_BACKEND.unloadChunk?.(chunkListUrl);
+    return true;
+}
+/**
+ * Disposes of a chunk and its corresponding exclusive modules.
+ *
+ * @returns Whether the chunk was disposed of.
+ */ function disposeChunk(chunkPath) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    // This should happen whether the chunk has any modules in it or not.
+    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
+    DEV_BACKEND.unloadChunk?.(chunkUrl);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    if (chunkModules == null) {
+        return false;
+    }
+    chunkModules.delete(chunkPath);
+    for (const moduleId of chunkModules){
+        const moduleChunks = moduleChunksMap.get(moduleId);
+        moduleChunks.delete(chunkPath);
+        const noRemainingChunks = moduleChunks.size === 0;
+        if (noRemainingChunks) {
+            moduleChunksMap.delete(moduleId);
+            disposeModule(moduleId, 'clear');
+            availableModules.delete(moduleId);
+        }
+    }
+    return true;
+}
+/**
+ * Adds a module to a chunk.
+ */ function addModuleToChunk(moduleId, chunkPath) {
+    let moduleChunks = moduleChunksMap.get(moduleId);
+    if (!moduleChunks) {
+        moduleChunks = new Set([
+            chunkPath
+        ]);
+        moduleChunksMap.set(moduleId, moduleChunks);
+    } else {
+        moduleChunks.add(chunkPath);
+    }
+    let chunkModules = chunkModulesMap.get(chunkPath);
+    if (!chunkModules) {
+        chunkModules = new Set([
+            moduleId
+        ]);
+        chunkModulesMap.set(chunkPath, chunkModules);
+    } else {
+        chunkModules.add(moduleId);
+    }
+}
+/**
+ * Marks a chunk list as a runtime chunk list. There can be more than one
+ * runtime chunk list. For instance, integration tests can have multiple chunk
+ * groups loaded at runtime, each with its own chunk list.
+ */ function markChunkListAsRuntime(chunkListPath) {
+    runtimeChunkLists.add(chunkListPath);
+}
+function registerChunk(registration) {
+    const chunkPath = getPathFromScript(registration[0]);
+    let runtimeParams;
+    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
+    if (registration.length === 2) {
+        runtimeParams = registration[1];
+    } else {
+        runtimeParams = undefined;
+        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
+    }
+    return BACKEND.registerChunk(chunkPath, runtimeParams);
+}
+/**
+ * Subscribes to chunk list updates from the update server and applies them.
+ */ function registerChunkList(chunkList) {
+    const chunkListScript = chunkList.script;
+    const chunkListPath = getPathFromScript(chunkListScript);
+    // The "chunk" is also registered to finish the loading in the backend
+    BACKEND.registerChunk(chunkListPath);
+    globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath)
+    ]);
+    // Adding chunks to chunk lists and vice versa.
+    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
+    if (chunkList.source === 'entry') {
+        markChunkListAsRuntime(chunkListPath);
+    }
+}
+globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
+/**
+ * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
+ *
+ * It will be appended to the base runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
+/// <reference path="../../../shared/runtime-types.d.ts" />
+function getChunkSuffixFromScriptSrc() {
+    // TURBOPACK_CHUNK_SUFFIX is set in web workers
+    return (self.TURBOPACK_CHUNK_SUFFIX ?? document?.currentScript?.getAttribute?.('src')?.replace(/^(.*(?=\?)|^.*$)/, '')) || '';
+}
+let BACKEND;
+/**
+ * Maps chunk paths to the corresponding resolver.
+ */ const chunkResolvers = new Map();
+(()=>{
+    BACKEND = {
+        async registerChunk (chunkPath, params) {
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            const resolver = getOrCreateResolver(chunkUrl);
+            resolver.resolve();
+            if (params == null) {
+                return;
+            }
+            for (const otherChunkData of params.otherChunks){
+                const otherChunkPath = getChunkPath(otherChunkData);
+                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
+                // Chunk might have started loading, so we want to avoid triggering another load.
+                getOrCreateResolver(otherChunkUrl);
+            }
+            // This waits for chunks to be loaded, but also marks included items as available.
+            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
+            if (params.runtimeModuleIds.length > 0) {
+                for (const moduleId of params.runtimeModuleIds){
+                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
+                }
+            }
+        },
+        /**
+     * Loads the given chunk, and returns a promise that resolves once the chunk
+     * has been loaded.
+     */ loadChunkCached (sourceType, chunkUrl) {
+            return doLoadChunk(sourceType, chunkUrl);
+        },
+        async loadWebAssembly (_sourceType, _sourceData, wasmChunkPath, _edgeModule, importsObj) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            const { instance } = await WebAssembly.instantiateStreaming(req, importsObj);
+            return instance.exports;
+        },
+        async loadWebAssemblyModule (_sourceType, _sourceData, wasmChunkPath, _edgeModule) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            return await WebAssembly.compileStreaming(req);
+        }
+    };
+    function getOrCreateResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        return resolver;
+    }
+    /**
+   * Loads the given chunk, and returns a promise that resolves once the chunk
+   * has been loaded.
+   */ function doLoadChunk(sourceType, chunkUrl) {
+        const resolver = getOrCreateResolver(chunkUrl);
+        if (resolver.loadingStarted) {
+            return resolver.promise;
+        }
+        if (sourceType === SourceType.Runtime) {
+            // We don't need to load chunks references from runtime code, as they're already
+            // present in the DOM.
+            resolver.loadingStarted = true;
+            if (isCss(chunkUrl)) {
+                // CSS chunks do not register themselves, and as such must be marked as
+                // loaded instantly.
+                resolver.resolve();
+            }
+            // We need to wait for JS chunks to register themselves within `registerChunk`
+            // before we can start instantiating runtime modules, hence the absence of
+            // `resolver.resolve()` in this branch.
+            return resolver.promise;
+        }
+        if (typeof importScripts === 'function') {
+            // We're in a web worker
+            if (isCss(chunkUrl)) {
+            // ignore
+            } else if (isJs(chunkUrl)) {
+                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
+                importScripts(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
+            }
+        } else {
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length > 0) {
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolver.resolve();
+                } else {
+                    const link = document.createElement('link');
+                    link.rel = 'stylesheet';
+                    link.href = chunkUrl;
+                    link.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    link.onload = ()=>{
+                        // CSS chunks do not register themselves, and as such must be marked as
+                        // loaded instantly.
+                        resolver.resolve();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(link);
+                }
+            } else if (isJs(chunkUrl)) {
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    // There is this edge where the script already failed loading, but we
+                    // can't detect that. The Promise will never resolve in this case.
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            resolver.reject();
+                        });
+                    }
+                } else {
+                    const script = document.createElement('script');
+                    script.src = chunkUrl;
+                    // We'll only mark the chunk as loaded once the script has been executed,
+                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
+                    // this branch.
+                    script.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(script);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        }
+        resolver.loadingStarted = true;
+        return resolver.promise;
+    }
+    function fetchWebAssembly(wasmChunkPath) {
+        return fetch(getChunkRelativeUrl(wasmChunkPath));
+    }
+})();
+/**
+ * This file contains the runtime code specific to the Turbopack development
+ * ECMAScript DOM runtime.
+ *
+ * It will be appended to the base development runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
+/// <reference path="../base/dev-base.ts" />
+/// <reference path="./runtime-backend-dom.ts" />
+/// <reference path="../../../shared/require-type.d.ts" />
+let DEV_BACKEND;
+(()=>{
+    DEV_BACKEND = {
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${chunkUrl}"],link[href^="${chunkUrl}?"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
+                }
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        },
+        reloadChunk (chunkUrl) {
+            return new Promise((resolve, reject)=>{
+                if (!isCss(chunkUrl)) {
+                    reject(new Error('The DOM backend can only reload CSS chunks'));
+                    return;
+                }
+                const decodedChunkUrl = decodeURI(chunkUrl);
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length === 0) {
+                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
+                    return;
+                }
+                const link = document.createElement('link');
+                link.rel = 'stylesheet';
+                if (navigator.userAgent.includes('Firefox')) {
+                    // Firefox won't reload CSS files that were previously loaded on the current page,
+                    // we need to add a query param to make sure CSS is actually reloaded from the server.
+                    //
+                    // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
+                    //
+                    // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag
+                    // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726
+                    link.href = `${chunkUrl}?ts=${Date.now()}`;
+                } else {
+                    link.href = chunkUrl;
+                }
+                link.onerror = ()=>{
+                    reject();
+                };
+                link.onload = ()=>{
+                    // First load the new CSS, then remove the old ones. This prevents visible
+                    // flickering that would happen in-between removing the previous CSS and
+                    // loading the new one.
+                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolve();
+                };
+                // Make sure to insert the new CSS right after the previous one, so that
+                // its precedence is higher.
+                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
+            });
+        },
+        restart: ()=>self.location.reload()
+    };
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
+    }
+})();
+function _eval({ code, url, map }) {
+    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX)}`;
+    if (map) {
+        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
+        // See https://stackoverflow.com/a/26603875
+        unescape(encodeURIComponent(map)))}`;
+    }
+    // eslint-disable-next-line no-eval
+    return eval(code);
+}
+const chunksToRegister = globalThis.TURBOPACK;
+globalThis.TURBOPACK = { push: registerChunk };
+chunksToRegister.forEach(registerChunk);
+const chunkListsToRegister = globalThis.TURBOPACK_CHUNK_LISTS || [];
+globalThis.TURBOPACK_CHUNK_LISTS = { push: registerChunkList };
+chunkListsToRegister.forEach(registerChunkList);
+})();
+
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js
new file mode 100644
index 00000000000000..45878e1ade87a8
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js
@@ -0,0 +1,22 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js",
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js (static in ecmascript)", ((__turbopack_context__) => {
+
+__turbopack_context__.v("/static/worker.60655f93.js");}),
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js [test] (ecmascript, worker loader)", ((__turbopack_context__) => {
+
+__turbopack_context__.v(__turbopack_context__.b("output/6642e_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js", ["output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_841f9693.js","output/ba425_crates_turbopack-tests_tests_snapshot_workers_basic_input_worker_01a12aa6.js"], false));
+}),
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js [test] (ecmascript)", ((__turbopack_context__, module, exports) => {
+
+const __TURBOPACK__import$2e$meta__ = {
+    get url () {
+        return `file://${__turbopack_context__.P("turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js")}`;
+    }
+};
+console.log('index.js');
+const url = new __turbopack_context__.U(__turbopack_context__.r("[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js (static in ecmascript)"));
+new Worker(__turbopack_context__.r("[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/worker.js [test] (ecmascript, worker loader)"));
+}),
+]);
+
+//# sourceMappingURL=turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js.map
new file mode 100644
index 00000000000000..de69f645a790d8
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_input_73fc86c5._.js.map
@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 10, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/input/index.js"],"sourcesContent":["console.log('index.js')\nconst url = new URL('./worker.js', import.meta.url)\nnew Worker(url)\n"],"names":["console","log","url","Worker"],"mappings":";;;;;AAAAA,QAAQC,GAAG,CAAC;AACZ,MAAMC;AACN,IAAIC"}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js.map
new file mode 100644
index 00000000000000..0470b96a8e80b4
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_basic_output_2867ca5f._.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/worker-entrypoint.ts"],"sourcesContent":["/**\n * Worker entrypoint bootstrap.\n */\n\ninterface WorkerBootstrapConfig {\n  // TURBOPACK_CHUNK_SUFFIX\n  S?: string\n  // NEXT_DEPLOYMENT_ID\n  N?: string\n  // TURBOPACK_NEXT_CHUNK_URLS\n  NC?: string[]\n}\n\n;(() => {\n  function abort(message: string): never {\n    console.error(message)\n    throw new Error(message)\n  }\n\n  // Security: Ensure this code is running in a worker environment to prevent\n  // the worker entrypoint being used as an XSS gadget. If this is a worker, we\n  // know that the origin of the caller is the same as our origin.\n  if (\n    typeof (self as any)['WorkerGlobalScope'] === 'undefined' ||\n    !(self instanceof (self as any)['WorkerGlobalScope'])\n  ) {\n    abort('Worker entrypoint must be loaded in a worker context')\n  }\n\n  const url = new URL(location.href)\n\n  // Try querystring first (SharedWorker), then hash (regular Worker)\n  let paramsString = url.searchParams.get('params')\n  if (!paramsString && url.hash.startsWith('#params=')) {\n    paramsString = decodeURIComponent(url.hash.slice('#params='.length))\n  }\n\n  if (!paramsString) abort('Missing worker bootstrap config')\n\n  // Safety: this string requires that a script on the same origin has loaded\n  // this code as a module. We still don't fully trust it, so we'll validate the\n  // types and ensure that the next chunk URLs are same-origin.\n  const config: WorkerBootstrapConfig = JSON.parse(paramsString)\n\n  const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : ''\n  const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : ''\n  // In a normal browser context, the runtime can figure out which chunk is\n  // currently executing via `document.currentScript`. Workers don't have that\n  // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead\n  // (`reverse()`d below).\n  //\n  // Each chunk pops its URL off the front of the array when it runs, so we need\n  // to store them in reverse order to make sure the first chunk to execute sees\n  // its own URL at the front.\n  const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : []\n\n  Object.assign(self, {\n    TURBOPACK_CHUNK_SUFFIX,\n    TURBOPACK_NEXT_CHUNK_URLS,\n    NEXT_DEPLOYMENT_ID,\n  })\n\n  if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {\n    const scriptsToLoad: string[] = []\n    for (const chunk of TURBOPACK_NEXT_CHUNK_URLS) {\n      // Chunks are relative to the origin.\n      const chunkUrl = new URL(chunk, location.origin)\n      // Security: Only load scripts from the same origin. This prevents this\n      // worker entrypoint from being used as a gadget to load scripts from\n      // foreign origins if someone happens to find a separate XSS vector\n      // elsewhere on this origin.\n      if (chunkUrl.origin !== location.origin) {\n        abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`)\n      }\n      scriptsToLoad.push(chunkUrl.toString())\n    }\n\n    TURBOPACK_NEXT_CHUNK_URLS.reverse()\n    importScripts(...scriptsToLoad)\n  }\n})()\n"],"names":["abort","message","console","error","Error","self","url","URL","location","href","paramsString","searchParams","get","hash","startsWith","decodeURIComponent","slice","length","config","JSON","parse","TURBOPACK_CHUNK_SUFFIX","S","NEXT_DEPLOYMENT_ID","N","TURBOPACK_NEXT_CHUNK_URLS","Array","isArray","NC","Object","assign","scriptsToLoad","chunk","chunkUrl","origin","push","toString","reverse","importScripts"],"mappings":"AAAA;;CAEC;AAWA,CAAC;IACA,SAASA,MAAMC,OAAe;QAC5BC,QAAQC,KAAK,CAACF;QACd,MAAM,IAAIG,MAAMH;IAClB;IAEA,2EAA2E;IAC3E,6EAA6E;IAC7E,gEAAgE;IAChE,IACE,OAAO,AAACI,IAAY,CAAC,oBAAoB,KAAK,eAC9C,CAAC,CAACA,gBAAgB,AAACA,IAAY,CAAC,oBAAoB,GACpD;QACAL,MAAM;IACR;IAEA,MAAMM,MAAM,IAAIC,IAAIC,SAASC,IAAI;IAEjC,mEAAmE;IACnE,IAAIC,eAAeJ,IAAIK,YAAY,CAACC,GAAG,CAAC;IACxC,IAAI,CAACF,gBAAgBJ,IAAIO,IAAI,CAACC,UAAU,CAAC,aAAa;QACpDJ,eAAeK,mBAAmBT,IAAIO,IAAI,CAACG,KAAK,CAAC,WAAWC,MAAM;IACpE;IAEA,IAAI,CAACP,cAAcV,MAAM;IAEzB,2EAA2E;IAC3E,8EAA8E;IAC9E,6DAA6D;IAC7D,MAAMkB,SAAgCC,KAAKC,KAAK,CAACV;IAEjD,MAAMW,yBAAyB,OAAOH,OAAOI,CAAC,KAAK,WAAWJ,OAAOI,CAAC,GAAG;IACzE,MAAMC,qBAAqB,OAAOL,OAAOM,CAAC,KAAK,WAAWN,OAAOM,CAAC,GAAG;IACrE,yEAAyE;IACzE,4EAA4E;IAC5E,mEAAmE;IACnE,wBAAwB;IACxB,EAAE;IACF,8EAA8E;IAC9E,8EAA8E;IAC9E,4BAA4B;IAC5B,MAAMC,4BAA4BC,MAAMC,OAAO,CAACT,OAAOU,EAAE,IAAIV,OAAOU,EAAE,GAAG,EAAE;IAE3EC,OAAOC,MAAM,CAACzB,MAAM;QAClBgB;QACAI;QACAF;IACF;IAEA,IAAIE,0BAA0BR,MAAM,GAAG,GAAG;QACxC,MAAMc,gBAA0B,EAAE;QAClC,KAAK,MAAMC,SAASP,0BAA2B;YAC7C,qCAAqC;YACrC,MAAMQ,WAAW,IAAI1B,IAAIyB,OAAOxB,SAAS0B,MAAM;YAC/C,uEAAuE;YACvE,qEAAqE;YACrE,mEAAmE;YACnE,4BAA4B;YAC5B,IAAID,SAASC,MAAM,KAAK1B,SAAS0B,MAAM,EAAE;gBACvClC,MAAM,CAAC,6CAA6C,EAAEiC,SAASC,MAAM,EAAE;YACzE;YACAH,cAAcI,IAAI,CAACF,SAASG,QAAQ;QACtC;QAEAX,0BAA0BY,OAAO;QACjCC,iBAAiBP;IACnB;AACF,CAAC","ignoreList":[0]}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/static/worker.60655f93.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/static/worker.60655f93.js
new file mode 100644
index 00000000000000..a0247b1075e4f7
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/basic/static/worker.60655f93.js
@@ -0,0 +1,2 @@
+console.log('worker.js')
+self.postMessage('hello')
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js
new file mode 100644
index 00000000000000..f693474feacf7f
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js
@@ -0,0 +1,2 @@
+const url = new URL('./worker.js', import.meta.url)
+new SharedWorker(url)
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js
new file mode 100644
index 00000000000000..01c30ecd51fc9c
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js
@@ -0,0 +1 @@
+self.onconnect = (e) => e.ports[0].postMessage('hello')
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/options.json b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/options.json
new file mode 100644
index 00000000000000..a04426e250932b
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/options.json
@@ -0,0 +1,6 @@
+{
+  "runtime": "Browser",
+  "runtimeType": "Development",
+  "minifyType": "NoMinify",
+  "environment": "Browser"
+}
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/6642e_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/6642e_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js
new file mode 100644
index 00000000000000..5f159495eab1ea
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/6642e_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js
@@ -0,0 +1,62 @@
+/**
+ * Worker entrypoint bootstrap.
+ */ ;
+(()=>{
+    function abort(message) {
+        console.error(message);
+        throw new Error(message);
+    }
+    // Security: Ensure this code is running in a worker environment to prevent
+    // the worker entrypoint being used as an XSS gadget. If this is a worker, we
+    // know that the origin of the caller is the same as our origin.
+    if (typeof self['WorkerGlobalScope'] === 'undefined' || !(self instanceof self['WorkerGlobalScope'])) {
+        abort('Worker entrypoint must be loaded in a worker context');
+    }
+    const url = new URL(location.href);
+    // Try querystring first (SharedWorker), then hash (regular Worker)
+    let paramsString = url.searchParams.get('params');
+    if (!paramsString && url.hash.startsWith('#params=')) {
+        paramsString = decodeURIComponent(url.hash.slice('#params='.length));
+    }
+    if (!paramsString) abort('Missing worker bootstrap config');
+    // Safety: this string requires that a script on the same origin has loaded
+    // this code as a module. We still don't fully trust it, so we'll validate the
+    // types and ensure that the next chunk URLs are same-origin.
+    const config = JSON.parse(paramsString);
+    const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : '';
+    const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : '';
+    // In a normal browser context, the runtime can figure out which chunk is
+    // currently executing via `document.currentScript`. Workers don't have that
+    // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead
+    // (`reverse()`d below).
+    //
+    // Each chunk pops its URL off the front of the array when it runs, so we need
+    // to store them in reverse order to make sure the first chunk to execute sees
+    // its own URL at the front.
+    const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : [];
+    Object.assign(self, {
+        TURBOPACK_CHUNK_SUFFIX,
+        TURBOPACK_NEXT_CHUNK_URLS,
+        NEXT_DEPLOYMENT_ID
+    });
+    if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {
+        const scriptsToLoad = [];
+        for (const chunk of TURBOPACK_NEXT_CHUNK_URLS){
+            // Chunks are relative to the origin.
+            const chunkUrl = new URL(chunk, location.origin);
+            // Security: Only load scripts from the same origin. This prevents this
+            // worker entrypoint from being used as a gadget to load scripts from
+            // foreign origins if someone happens to find a separate XSS vector
+            // elsewhere on this origin.
+            if (chunkUrl.origin !== location.origin) {
+                abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`);
+            }
+            scriptsToLoad.push(chunkUrl.toString());
+        }
+        TURBOPACK_NEXT_CHUNK_URLS.reverse();
+        importScripts(...scriptsToLoad);
+    }
+})();
+
+
+//# sourceMappingURL=turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js.map
new file mode 100644
index 00000000000000..2092500cff64fb
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js.map
@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","err","asyncModule","body","hasAwait","depQueues","Set","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 514, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 747, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1766, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"AAAA;;;;;CAKC,GAED,oDAAoD,GAEpD,gDAAgD;AAChD,4CAA4C;AAC5C,iDAAiD;AACjD,0DAA0D;AAE1D,IAAIA;AACH,CAAC;IACAA,cAAc;QACZC,aAAYC,QAAQ;YAClBC,eAAeD;YAEf,gFAAgF;YAChF,MAAME,kBAAkBC,UAAUH;YAElC,IAAII,MAAMJ,WAAW;gBACnB,MAAMK,QAAQC,SAASC,gBAAgB,CACrC,CAAC,WAAW,EAAEP,SAAS,eAAe,EAAEA,SAAS,eAAe,EAAEE,gBAAgB,eAAe,EAAEA,gBAAgB,GAAG,CAAC;gBAEzH,KAAK,MAAMM,QAAQC,MAAMC,IAAI,CAACL,OAAQ;oBACpCG,KAAKG,MAAM;gBACb;YACF,OAAO,IAAIC,KAAKZ,WAAW;gBACzB,mEAAmE;gBACnE,0BAA0B;gBAC1B,uEAAuE;gBACvE,4DAA4D;gBAC5D,MAAMa,UAAUP,SAASC,gBAAgB,CACvC,CAAC,YAAY,EAAEP,SAAS,gBAAgB,EAAEA,SAAS,gBAAgB,EAAEE,gBAAgB,gBAAgB,EAAEA,gBAAgB,GAAG,CAAC;gBAE7H,KAAK,MAAMY,UAAUL,MAAMC,IAAI,CAACG,SAAU;oBACxCC,OAAOH,MAAM;gBACf;YACF,OAAO;gBACL,MAAM,IAAII,MAAM,CAAC,mCAAmC,EAAEf,UAAU;YAClE;QACF;QAEAgB,aAAYhB,QAAQ;YAClB,OAAO,IAAIiB,QAAc,CAACC,SAASC;gBACjC,IAAI,CAACf,MAAMJ,WAAW;oBACpBmB,OAAO,IAAIJ,MAAM;oBACjB;gBACF;gBAEA,MAAMb,kBAAkBC,UAAUH;gBAClC,MAAMoB,gBAAgBd,SAASC,gBAAgB,CAC7C,CAAC,2BAA2B,EAAEP,SAAS,+BAA+B,EAAEA,SAAS,+BAA+B,EAAEE,gBAAgB,+BAA+B,EAAEA,gBAAgB,GAAG,CAAC;gBAGzL,IAAIkB,cAAcC,MAAM,KAAK,GAAG;oBAC9BF,OAAO,IAAIJ,MAAM,CAAC,gCAAgC,EAAEf,UAAU;oBAC9D;gBACF;gBAEA,MAAMQ,OAAOF,SAASgB,aAAa,CAAC;gBACpCd,KAAKe,GAAG,GAAG;gBAEX,IAAIC,UAAUC,SAAS,CAACC,QAAQ,CAAC,YAAY;oBAC3C,kFAAkF;oBAClF,sFAAsF;oBACtF,EAAE;oBACF,qFAAqF;oBACrF,EAAE;oBACF,oFAAoF;oBACpF,6FAA6F;oBAC7FlB,KAAKmB,IAAI,GAAG,GAAG3B,SAAS,IAAI,EAAE4B,KAAKC,GAAG,IAAI;gBAC5C,OAAO;oBACLrB,KAAKmB,IAAI,GAAG3B;gBACd;gBAEAQ,KAAKsB,OAAO,GAAG;oBACbX;gBACF;gBACAX,KAAKuB,MAAM,GAAG;oBACZ,0EAA0E;oBAC1E,wEAAwE;oBACxE,uBAAuB;oBACvB,KAAK,MAAMC,gBAAgBvB,MAAMC,IAAI,CAACU,eACpCY,aAAarB,MAAM;oBAErB,uEAAuE;oBACvE,oBAAoB;oBACpBO;gBACF;gBAEA,wEAAwE;gBACxE,4BAA4B;gBAC5BE,aAAa,CAAC,EAAE,CAACa,aAAa,CAAEC,YAAY,CAC1C1B,MACAY,aAAa,CAAC,EAAE,CAACe,WAAW;YAEhC;QACF;QAEAC,SAAS,IAAMC,KAAKC,QAAQ,CAACC,MAAM;IACrC;IAEA,SAAStC,eAAeD,QAAkB;QACxCwC,eAAeC,MAAM,CAACzC;IACxB;AACF,CAAC;AAED,SAAS0C,MAAM,EAAEC,IAAI,EAAEC,GAAG,EAAEC,GAAG,EAAyB;IACtDF,QAAQ,CAAC,kBAAkB,EAAEG,UAC3BR,SAASS,MAAM,GAAGC,kBAAkBJ,MAAMK,eACzC;IACH,IAAIJ,KAAK;QACPF,QAAQ,CAAC,kEAAkE,EAAEO,KAC3E,0EAA0E;QAC1E,2CAA2C;QAC3CC,SAASC,mBAAmBP,QAC3B;IACL;IAEA,mCAAmC;IACnC,OAAOQ,KAAKV;AACd","ignoreList":[0]}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js.map
new file mode 100644
index 00000000000000..2092500cff64fb
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js.map
@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/shared/runtime-utils.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * TurboPack ECMAScript runtimes.\n *\n * It will be prepended to the runtime code of each runtime.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"./runtime-types.d.ts\" />\n\ntype EsmNamespaceObject = Record<string, any>\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent<M>(\n  id: ModuleId,\n  sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap<Module, ReexportedObjects>()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n  this: TurbopackBaseContext<Module>,\n  module: Module,\n  exports: Exports\n) {\n  this.m = module\n  // We need to store this here instead of accessing it from the module object to:\n  // 1. Make it available to factories directly, since we rewrite `this` to\n  //    `__turbopack_context__.e` in CJS modules.\n  // 2. Support async modules which rewrite `module.exports` to a promise, so we\n  //    can still access the original exports object from functions like\n  //    `esmExport`\n  // Ideally we could find a new approach for async modules and drop this property altogether.\n  this.e = exports\n}\nconst contextPrototype = Context.prototype as TurbopackBaseContext<Module>\n\ntype ModuleContextMap = Record<ModuleId, ModuleContextEntry>\n\ninterface ModuleContextEntry {\n  id: () => ModuleId\n  module: () => any\n}\n\ninterface ModuleContext {\n  // require call\n  (moduleId: string): Exports | EsmNamespaceObject\n\n  // async import call\n  import(moduleId: string): Promise<Exports | EsmNamespaceObject>\n\n  keys(): ModuleId[]\n\n  resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent<M extends Module> = (\n  moduleId: M['id'],\n  parentModule: M\n) => M\n\ndeclare function getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty\nconst toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag\n\nfunction defineProp(\n  obj: any,\n  name: PropertyKey,\n  options: PropertyDescriptor & ThisType<any>\n) {\n  if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n  moduleCache: ModuleCache<Module>,\n  id: ModuleId\n): Module {\n  let module = moduleCache[id]\n  if (!module) {\n    // This is invoked when a module is merged into another module, thus it wasn't invoked via\n    // instantiateModule and the cache entry wasn't created yet.\n    module = createModuleObject(id)\n    moduleCache[id] = module\n  }\n  return module\n}\n\n/**\n * Creates the module object. Only done here to ensure all module objects have the same shape.\n */\nfunction createModuleObject(id: ModuleId): Module {\n  return {\n    exports: {},\n    error: undefined,\n    id,\n    namespaceObject: undefined,\n  }\n}\n\ntype BindingTag = 0\nconst BindingTag_Value = 0 as BindingTag\n\n// an arbitrary sequence of bindings as\n// - a prop name\n// - BindingTag_Value, a value to be bound directly, or\n// - 1 or 2 functions to bind as getters and sdetters\ntype EsmBindings = Array<\n  string | BindingTag | (() => unknown) | ((v: unknown) => void) | unknown\n>\n\n/**\n * Adds the getters to the exports object.\n */\nfunction esm(exports: Exports, bindings: EsmBindings) {\n  defineProp(exports, '__esModule', { value: true })\n  if (toStringTag) defineProp(exports, toStringTag, { value: 'Module' })\n  let i = 0\n  while (i < bindings.length) {\n    const propName = bindings[i++] as string\n    const tagOrFunction = bindings[i++]\n    if (typeof tagOrFunction === 'number') {\n      if (tagOrFunction === BindingTag_Value) {\n        defineProp(exports, propName, {\n          value: bindings[i++],\n          enumerable: true,\n          writable: false,\n        })\n      } else {\n        throw new Error(`unexpected tag: ${tagOrFunction}`)\n      }\n    } else {\n      const getterFn = tagOrFunction as () => unknown\n      if (typeof bindings[i] === 'function') {\n        const setterFn = bindings[i++] as (v: unknown) => void\n        defineProp(exports, propName, {\n          get: getterFn,\n          set: setterFn,\n          enumerable: true,\n        })\n      } else {\n        defineProp(exports, propName, {\n          get: getterFn,\n          enumerable: true,\n        })\n      }\n    }\n  }\n  Object.seal(exports)\n}\n\n/**\n * Makes the module an ESM with exports\n */\nfunction esmExport(\n  this: TurbopackBaseContext<Module>,\n  bindings: EsmBindings,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Module['exports']\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  module.namespaceObject = exports\n  esm(exports, bindings)\n}\ncontextPrototype.s = esmExport\n\ntype ReexportedObjects = Record<PropertyKey, unknown>[]\nfunction ensureDynamicExports(\n  module: Module,\n  exports: Exports\n): ReexportedObjects {\n  let reexportedObjects: ReexportedObjects | undefined =\n    REEXPORTED_OBJECTS.get(module)\n\n  if (!reexportedObjects) {\n    REEXPORTED_OBJECTS.set(module, (reexportedObjects = []))\n    module.exports = module.namespaceObject = new Proxy(exports, {\n      get(target, prop) {\n        if (\n          hasOwnProperty.call(target, prop) ||\n          prop === 'default' ||\n          prop === '__esModule'\n        ) {\n          return Reflect.get(target, prop)\n        }\n        for (const obj of reexportedObjects!) {\n          const value = Reflect.get(obj, prop)\n          if (value !== undefined) return value\n        }\n        return undefined\n      },\n      ownKeys(target) {\n        const keys = Reflect.ownKeys(target)\n        for (const obj of reexportedObjects!) {\n          for (const key of Reflect.ownKeys(obj)) {\n            if (key !== 'default' && !keys.includes(key)) keys.push(key)\n          }\n        }\n        return keys\n      },\n    })\n  }\n  return reexportedObjects\n}\n\n/**\n * Dynamically exports properties from an object\n */\nfunction dynamicExport(\n  this: TurbopackBaseContext<Module>,\n  object: Record<string, any>,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  let exports: Exports\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n    exports = module.exports\n  } else {\n    module = this.m\n    exports = this.e\n  }\n  const reexportedObjects = ensureDynamicExports(module, exports)\n\n  if (typeof object === 'object' && object !== null) {\n    reexportedObjects.push(object)\n  }\n}\ncontextPrototype.j = dynamicExport\n\nfunction exportValue(\n  this: TurbopackBaseContext<Module>,\n  value: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = value\n}\ncontextPrototype.v = exportValue\n\nfunction exportNamespace(\n  this: TurbopackBaseContext<Module>,\n  namespace: any,\n  id: ModuleId | undefined\n) {\n  let module: Module\n  if (id != null) {\n    module = getOverwrittenModule(this.c, id)\n  } else {\n    module = this.m\n  }\n  module.exports = module.namespaceObject = namespace\n}\ncontextPrototype.n = exportNamespace\n\nfunction createGetter(obj: Record<string | symbol, any>, key: string | symbol) {\n  return () => obj[key]\n}\n\n/**\n * @returns prototype of the object\n */\nconst getProto: (obj: any) => any = Object.getPrototypeOf\n  ? (obj) => Object.getPrototypeOf(obj)\n  : (obj) => obj.__proto__\n\n/** Prototypes that are not expanded for exports */\nconst LEAF_PROTOTYPES = [null, getProto({}), getProto([]), getProto(getProto)]\n\n/**\n * @param raw\n * @param ns\n * @param allowExportDefault\n *   * `false`: will have the raw module as default export\n *   * `true`: will have the default property as default export\n */\nfunction interopEsm(\n  raw: Exports,\n  ns: EsmNamespaceObject,\n  allowExportDefault?: boolean\n) {\n  const bindings: EsmBindings = []\n  let defaultLocation = -1\n  for (\n    let current = raw;\n    (typeof current === 'object' || typeof current === 'function') &&\n    !LEAF_PROTOTYPES.includes(current);\n    current = getProto(current)\n  ) {\n    for (const key of Object.getOwnPropertyNames(current)) {\n      bindings.push(key, createGetter(raw, key))\n      if (defaultLocation === -1 && key === 'default') {\n        defaultLocation = bindings.length - 1\n      }\n    }\n  }\n\n  // this is not really correct\n  // we should set the `default` getter if the imported module is a `.cjs file`\n  if (!(allowExportDefault && defaultLocation >= 0)) {\n    // Replace the binding with one for the namespace itself in order to preserve iteration order.\n    if (defaultLocation >= 0) {\n      // Replace the getter with the value\n      bindings.splice(defaultLocation, 1, BindingTag_Value, raw)\n    } else {\n      bindings.push('default', BindingTag_Value, raw)\n    }\n  }\n\n  esm(ns, bindings)\n  return ns\n}\n\nfunction createNS(raw: Module['exports']): EsmNamespaceObject {\n  if (typeof raw === 'function') {\n    return function (this: any, ...args: any[]) {\n      return raw.apply(this, args)\n    }\n  } else {\n    return Object.create(null)\n  }\n}\n\nfunction esmImport(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exclude<Module['namespaceObject'], undefined> {\n  const module = getOrInstantiateModuleFromParent(id, this.m)\n\n  // any ES module has to have `module.namespaceObject` defined.\n  if (module.namespaceObject) return module.namespaceObject\n\n  // only ESM can be an async module, so we don't need to worry about exports being a promise here.\n  const raw = module.exports\n  return (module.namespaceObject = interopEsm(\n    raw,\n    createNS(raw),\n    raw && (raw as any).__esModule\n  ))\n}\ncontextPrototype.i = esmImport\n\nfunction asyncLoader(\n  this: TurbopackBaseContext<Module>,\n  moduleId: ModuleId\n): Promise<Exports> {\n  const loader = this.r(moduleId) as (\n    importFunction: EsmImport\n  ) => Promise<Exports>\n  return loader(esmImport.bind(this))\n}\ncontextPrototype.A = asyncLoader\n\n// Add a simple runtime require so that environments without one can still pass\n// `typeof require` CommonJS checks so that exports are correctly registered.\nconst runtimeRequire =\n  // @ts-ignore\n  typeof require === 'function'\n    ? // @ts-ignore\n      require\n    : function require() {\n        throw new Error('Unexpected use of runtime require')\n      }\ncontextPrototype.t = runtimeRequire\n\nfunction commonJsRequire(\n  this: TurbopackBaseContext<Module>,\n  id: ModuleId\n): Exports {\n  return getOrInstantiateModuleFromParent(id, this.m).exports\n}\ncontextPrototype.r = commonJsRequire\n\n/**\n * Remove fragments and query parameters since they are never part of the context map keys\n *\n * This matches how we parse patterns at resolving time.  Arguably we should only do this for\n * strings passed to `import` but the resolve does it for `import` and `require` and so we do\n * here as well.\n */\nfunction parseRequest(request: string): string {\n  // Per the URI spec fragments can contain `?` characters, so we should trim it off first\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5\n  const hashIndex = request.indexOf('#')\n  if (hashIndex !== -1) {\n    request = request.substring(0, hashIndex)\n  }\n\n  const queryIndex = request.indexOf('?')\n  if (queryIndex !== -1) {\n    request = request.substring(0, queryIndex)\n  }\n\n  return request\n}\n/**\n * `require.context` and require/import expression runtime.\n */\nfunction moduleContext(map: ModuleContextMap): ModuleContext {\n  function moduleContext(id: string): Exports {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].module()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.keys = (): string[] => {\n    return Object.keys(map)\n  }\n\n  moduleContext.resolve = (id: string): ModuleId => {\n    id = parseRequest(id)\n    if (hasOwnProperty.call(map, id)) {\n      return map[id].id()\n    }\n\n    const e = new Error(`Cannot find module '${id}'`)\n    ;(e as any).code = 'MODULE_NOT_FOUND'\n    throw e\n  }\n\n  moduleContext.import = async (id: string) => {\n    return await (moduleContext(id) as Promise<Exports>)\n  }\n\n  return moduleContext\n}\ncontextPrototype.f = moduleContext\n\n/**\n * Returns the path of a chunk defined by its data.\n */\nfunction getChunkPath(chunkData: ChunkData): ChunkPath {\n  return typeof chunkData === 'string' ? chunkData : chunkData.path\n}\n\nfunction isPromise<T = any>(maybePromise: any): maybePromise is Promise<T> {\n  return (\n    maybePromise != null &&\n    typeof maybePromise === 'object' &&\n    'then' in maybePromise &&\n    typeof maybePromise.then === 'function'\n  )\n}\n\nfunction isAsyncModuleExt<T extends {}>(obj: T): obj is AsyncModuleExt & T {\n  return turbopackQueues in obj\n}\n\nfunction createPromise<T>() {\n  let resolve: (value: T | PromiseLike<T>) => void\n  let reject: (reason?: any) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    reject = rej\n    resolve = res\n  })\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  }\n}\n\n// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.\n// The CompressedModuleFactories format is\n// - 1 or more module ids\n// - a module factory function\n// So walking this is a little complex but the flat structure is also fast to\n// traverse, we can use `typeof` operators to distinguish the two cases.\nfunction installCompressedModuleFactories(\n  chunkModules: CompressedModuleFactories,\n  offset: number,\n  moduleFactories: ModuleFactories,\n  newModuleId?: (id: ModuleId) => void\n) {\n  let i = offset\n  while (i < chunkModules.length) {\n    let moduleId = chunkModules[i] as ModuleId\n    let end = i + 1\n    // Find our factory function\n    while (\n      end < chunkModules.length &&\n      typeof chunkModules[end] !== 'function'\n    ) {\n      end++\n    }\n    if (end === chunkModules.length) {\n      throw new Error('malformed chunk format, expected a factory function')\n    }\n    // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already\n    // present we know all the additional ids are also present, so we don't need to check.\n    if (!moduleFactories.has(moduleId)) {\n      const moduleFactoryFn = chunkModules[end] as Function\n      applyModuleFactoryName(moduleFactoryFn)\n      newModuleId?.(moduleId)\n      for (; i < end; i++) {\n        moduleId = chunkModules[i] as ModuleId\n        moduleFactories.set(moduleId, moduleFactoryFn)\n      }\n    }\n    i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.\n  }\n}\n\n// everything below is adapted from webpack\n// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13\n\nconst turbopackQueues = Symbol('turbopack queues')\nconst turbopackExports = Symbol('turbopack exports')\nconst turbopackError = Symbol('turbopack error')\n\nconst enum QueueStatus {\n  Unknown = -1,\n  Unresolved = 0,\n  Resolved = 1,\n}\n\ntype AsyncQueueFn = (() => void) & { queueCount: number }\ntype AsyncQueue = AsyncQueueFn[] & {\n  status: QueueStatus\n}\n\nfunction resolveQueue(queue?: AsyncQueue) {\n  if (queue && queue.status !== QueueStatus.Resolved) {\n    queue.status = QueueStatus.Resolved\n    queue.forEach((fn) => fn.queueCount--)\n    queue.forEach((fn) => (fn.queueCount-- ? fn.queueCount++ : fn()))\n  }\n}\n\ntype Dep = Exports | AsyncModulePromise | Promise<Exports>\n\ntype AsyncModuleExt = {\n  [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n  [turbopackExports]: Exports\n  [turbopackError]?: any\n}\n\ntype AsyncModulePromise<T = Exports> = Promise<T> & AsyncModuleExt\n\nfunction wrapDeps(deps: Dep[]): AsyncModuleExt[] {\n  return deps.map((dep): AsyncModuleExt => {\n    if (dep !== null && typeof dep === 'object') {\n      if (isAsyncModuleExt(dep)) return dep\n      if (isPromise(dep)) {\n        const queue: AsyncQueue = Object.assign([], {\n          status: QueueStatus.Unresolved,\n        })\n\n        const obj: AsyncModuleExt = {\n          [turbopackExports]: {},\n          [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => fn(queue),\n        }\n\n        dep.then(\n          (res) => {\n            obj[turbopackExports] = res\n            resolveQueue(queue)\n          },\n          (err) => {\n            obj[turbopackError] = err\n            resolveQueue(queue)\n          }\n        )\n\n        return obj\n      }\n    }\n\n    return {\n      [turbopackExports]: dep,\n      [turbopackQueues]: () => {},\n    }\n  })\n}\n\nfunction asyncModule(\n  this: TurbopackBaseContext<Module>,\n  body: (\n    handleAsyncDependencies: (\n      deps: Dep[]\n    ) => Exports[] | Promise<() => Exports[]>,\n    asyncResult: (err?: any) => void\n  ) => void,\n  hasAwait: boolean\n) {\n  const module = this.m\n  const queue: AsyncQueue | undefined = hasAwait\n    ? Object.assign([], { status: QueueStatus.Unknown })\n    : undefined\n\n  const depQueues: Set<AsyncQueue> = new Set()\n\n  const { resolve, reject, promise: rawPromise } = createPromise<Exports>()\n\n  const promise: AsyncModulePromise = Object.assign(rawPromise, {\n    [turbopackExports]: module.exports,\n    [turbopackQueues]: (fn) => {\n      queue && fn(queue)\n      depQueues.forEach(fn)\n      promise['catch'](() => {})\n    },\n  } satisfies AsyncModuleExt)\n\n  const attributes: PropertyDescriptor = {\n    get(): any {\n      return promise\n    },\n    set(v: any) {\n      // Calling `esmExport` leads to this.\n      if (v !== promise) {\n        promise[turbopackExports] = v\n      }\n    },\n  }\n\n  Object.defineProperty(module, 'exports', attributes)\n  Object.defineProperty(module, 'namespaceObject', attributes)\n\n  function handleAsyncDependencies(deps: Dep[]) {\n    const currentDeps = wrapDeps(deps)\n\n    const getResult = () =>\n      currentDeps.map((d) => {\n        if (d[turbopackError]) throw d[turbopackError]\n        return d[turbopackExports]\n      })\n\n    const { promise, resolve } = createPromise<() => Exports[]>()\n\n    const fn: AsyncQueueFn = Object.assign(() => resolve(getResult), {\n      queueCount: 0,\n    })\n\n    function fnQueue(q: AsyncQueue) {\n      if (q !== queue && !depQueues.has(q)) {\n        depQueues.add(q)\n        if (q && q.status === QueueStatus.Unresolved) {\n          fn.queueCount++\n          q.push(fn)\n        }\n      }\n    }\n\n    currentDeps.map((dep) => dep[turbopackQueues](fnQueue))\n\n    return fn.queueCount ? promise : getResult()\n  }\n\n  function asyncResult(err?: any) {\n    if (err) {\n      reject((promise[turbopackError] = err))\n    } else {\n      resolve(promise[turbopackExports])\n    }\n\n    resolveQueue(queue)\n  }\n\n  body(handleAsyncDependencies, asyncResult)\n\n  if (queue && queue.status === QueueStatus.Unknown) {\n    queue.status = QueueStatus.Unresolved\n  }\n}\ncontextPrototype.a = asyncModule\n\n/**\n * A pseudo \"fake\" URL object to resolve to its relative path.\n *\n * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this\n * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid\n * hydration mismatch.\n *\n * This is based on webpack's existing implementation:\n * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js\n */\nconst relativeURL = function relativeURL(this: any, inputUrl: string) {\n  const realUrl = new URL(inputUrl, 'x:/')\n  const values: Record<string, any> = {}\n  for (const key in realUrl) values[key] = (realUrl as any)[key]\n  values.href = inputUrl\n  values.pathname = inputUrl.replace(/[?#].*/, '')\n  values.origin = values.protocol = ''\n  values.toString = values.toJSON = (..._args: Array<any>) => inputUrl\n  for (const key in values)\n    Object.defineProperty(this, key, {\n      enumerable: true,\n      configurable: true,\n      value: values[key],\n    })\n}\nrelativeURL.prototype = URL.prototype\ncontextPrototype.U = relativeURL\n\n/**\n * Utility function to ensure all variants of an enum are handled.\n */\nfunction invariant(never: never, computeMessage: (arg: any) => string): never {\n  throw new Error(`Invariant: ${computeMessage(never)}`)\n}\n\n/**\n * A stub function to make `require` available but non-functional in ESM.\n */\nfunction requireStub(_moduleId: ModuleId): never {\n  throw new Error('dynamic usage of require is not supported')\n}\ncontextPrototype.z = requireStub\n\n// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.\ncontextPrototype.g = globalThis\n\ntype ContextConstructor<M> = {\n  new (module: Module, exports: Exports): TurbopackBaseContext<M>\n}\n\nfunction applyModuleFactoryName(factory: Function) {\n  // Give the module factory a nice name to improve stack traces.\n  Object.defineProperty(factory, 'name', {\n    value: 'module evaluation',\n  })\n}\n"],"names":["REEXPORTED_OBJECTS","WeakMap","Context","module","exports","m","e","contextPrototype","prototype","hasOwnProperty","Object","toStringTag","Symbol","defineProp","obj","name","options","call","defineProperty","getOverwrittenModule","moduleCache","id","createModuleObject","error","undefined","namespaceObject","BindingTag_Value","esm","bindings","value","i","length","propName","tagOrFunction","enumerable","writable","Error","getterFn","setterFn","get","set","seal","esmExport","c","s","ensureDynamicExports","reexportedObjects","Proxy","target","prop","Reflect","ownKeys","keys","key","includes","push","dynamicExport","object","j","exportValue","v","exportNamespace","namespace","n","createGetter","getProto","getPrototypeOf","__proto__","LEAF_PROTOTYPES","interopEsm","raw","ns","allowExportDefault","defaultLocation","current","getOwnPropertyNames","splice","createNS","args","apply","create","esmImport","getOrInstantiateModuleFromParent","__esModule","asyncLoader","moduleId","loader","r","bind","A","runtimeRequire","require","require1","t","commonJsRequire","parseRequest","request","hashIndex","indexOf","substring","queryIndex","moduleContext","map","code","resolve","import","f","getChunkPath","chunkData","path","isPromise","maybePromise","then","isAsyncModuleExt","turbopackQueues","createPromise","reject","promise","Promise","res","rej","installCompressedModuleFactories","chunkModules","offset","moduleFactories","newModuleId","end","has","moduleFactoryFn","applyModuleFactoryName","turbopackExports","turbopackError","resolveQueue","queue","status","forEach","fn","queueCount","wrapDeps","deps","dep","assign","err","asyncModule","body","hasAwait","depQueues","Set","rawPromise","attributes","handleAsyncDependencies","currentDeps","getResult","d","fnQueue","q","add","asyncResult","a","relativeURL","inputUrl","realUrl","URL","values","href","pathname","replace","origin","protocol","toString","toJSON","_args","configurable","U","invariant","never","computeMessage","requireStub","_moduleId","z","g","globalThis","factory"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 514, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/runtime-base.ts"],"sourcesContent":["/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *browser* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/globals.d.ts\" />\n/// <reference path=\"../../../shared/runtime-utils.ts\" />\n\n// Used in WebWorkers to tell the runtime about the chunk suffix\ndeclare var TURBOPACK_CHUNK_SUFFIX: string\n// Used in WebWorkers to tell the runtime about the current chunk url since it\n// can't be detected via `document.currentScript`. Note it's stored in reversed\n// order to use `push` and `pop`\ndeclare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined\n\n// Injected by rust code\ndeclare var CHUNK_BASE_PATH: string\ndeclare var CHUNK_SUFFIX: string\n\ninterface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {\n  R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n  Context.prototype as TurbopackBrowserBaseContext<unknown>\n\n// Provided by build or dev base\ndeclare function instantiateModule(\n  id: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module\n\ntype RuntimeParams = {\n  otherChunks: ChunkData[]\n  runtimeModuleIds: ModuleId[]\n}\n\ntype ChunkRegistration = [\n  chunkPath: ChunkScript,\n  ...([RuntimeParams] | CompressedModuleFactories),\n]\n\ntype ChunkList = {\n  script: ChunkListScript\n  chunks: ChunkData[]\n  source: 'entry' | 'dynamic'\n}\n\nenum SourceType {\n  /**\n   * The module was instantiated because it was included in an evaluated chunk's\n   * runtime.\n   * SourceData is a ChunkPath.\n   */\n  Runtime = 0,\n  /**\n   * The module was instantiated because a parent module imported it.\n   * SourceData is a ModuleId.\n   */\n  Parent = 1,\n  /**\n   * The module was instantiated because it was included in a chunk's hot module\n   * update.\n   * SourceData is an array of ModuleIds or undefined.\n   */\n  Update = 2,\n}\n\ntype SourceData = ChunkPath | ModuleId | ModuleId[] | undefined\ninterface RuntimeBackend {\n  registerChunk: (chunkPath: ChunkPath, params?: RuntimeParams) => void\n  /**\n   * Returns the same Promise for the same chunk URL.\n   */\n  loadChunkCached: (sourceType: SourceType, chunkUrl: ChunkUrl) => Promise<void>\n  loadWebAssembly: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module,\n    importsObj: WebAssembly.Imports\n  ) => Promise<Exports>\n  loadWebAssemblyModule: (\n    sourceType: SourceType,\n    sourceData: SourceData,\n    wasmChunkPath: ChunkPath,\n    edgeModule: () => WebAssembly.Module\n  ) => Promise<WebAssembly.Module>\n}\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map<ModuleId, Promise<any> | true> = new Map()\n\nconst availableModuleChunks: Map<ChunkPath, Promise<any> | true> = new Map()\n\nfunction factoryNotAvailableMessage(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): string {\n  let instantiationReason\n  switch (sourceType) {\n    case SourceType.Runtime:\n      instantiationReason = `as a runtime entry of chunk ${sourceData}`\n      break\n    case SourceType.Parent:\n      instantiationReason = `because it was required from module ${sourceData}`\n      break\n    case SourceType.Update:\n      instantiationReason = 'because of an HMR update'\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n  return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`\n}\n\nfunction loadChunk(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkData: ChunkData\n): Promise<void> {\n  return loadChunkInternal(SourceType.Parent, this.m.id, chunkData)\n}\nbrowserContextPrototype.l = loadChunk\n\nfunction loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {\n  return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)\n}\n\nasync function loadChunkInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkData: ChunkData\n): Promise<void> {\n  if (typeof chunkData === 'string') {\n    return loadChunkPath(sourceType, sourceData, chunkData)\n  }\n\n  const includedList = chunkData.included || []\n  const modulesPromises = includedList.map((included) => {\n    if (moduleFactories.has(included)) return true\n    return availableModules.get(included)\n  })\n  if (modulesPromises.length > 0 && modulesPromises.every((p) => p)) {\n    // When all included items are already loaded or loading, we can skip loading ourselves\n    await Promise.all(modulesPromises)\n    return\n  }\n\n  const includedModuleChunksList = chunkData.moduleChunks || []\n  const moduleChunksPromises = includedModuleChunksList\n    .map((included) => {\n      // TODO(alexkirsz) Do we need this check?\n      // if (moduleFactories[included]) return true;\n      return availableModuleChunks.get(included)\n    })\n    .filter((p) => p)\n\n  let promise: Promise<unknown>\n  if (moduleChunksPromises.length > 0) {\n    // Some module chunks are already loaded or loading.\n\n    if (moduleChunksPromises.length === includedModuleChunksList.length) {\n      // When all included module chunks are already loaded or loading, we can skip loading ourselves\n      await Promise.all(moduleChunksPromises)\n      return\n    }\n\n    const moduleChunksToLoad: Set<ChunkPath> = new Set()\n    for (const moduleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(moduleChunk)) {\n        moduleChunksToLoad.add(moduleChunk)\n      }\n    }\n\n    for (const moduleChunkToLoad of moduleChunksToLoad) {\n      const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad)\n\n      availableModuleChunks.set(moduleChunkToLoad, promise)\n\n      moduleChunksPromises.push(promise)\n    }\n\n    promise = Promise.all(moduleChunksPromises)\n  } else {\n    promise = loadChunkPath(sourceType, sourceData, chunkData.path)\n\n    // Mark all included module chunks as loading if they are not already loaded or loading.\n    for (const includedModuleChunk of includedModuleChunksList) {\n      if (!availableModuleChunks.has(includedModuleChunk)) {\n        availableModuleChunks.set(includedModuleChunk, promise)\n      }\n    }\n  }\n\n  for (const included of includedList) {\n    if (!availableModules.has(included)) {\n      // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.\n      // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.\n      availableModules.set(included, promise)\n    }\n  }\n\n  await promise\n}\n\nconst loadedChunk = Promise.resolve(undefined)\nconst instrumentedBackendLoadChunks = new WeakMap<\n  Promise<any>,\n  Promise<any> | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n  this: TurbopackBrowserBaseContext<Module>,\n  chunkUrl: ChunkUrl\n) {\n  return loadChunkByUrlInternal(SourceType.Parent, this.m.id, chunkUrl)\n}\nbrowserContextPrototype.L = loadChunkByUrl\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrlInternal(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkUrl: ChunkUrl\n): Promise<any> {\n  const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl)\n  let entry = instrumentedBackendLoadChunks.get(thenable)\n  if (entry === undefined) {\n    const resolve = instrumentedBackendLoadChunks.set.bind(\n      instrumentedBackendLoadChunks,\n      thenable,\n      loadedChunk\n    )\n    entry = thenable.then(resolve).catch((cause) => {\n      let loadReason: string\n      switch (sourceType) {\n        case SourceType.Runtime:\n          loadReason = `as a runtime dependency of chunk ${sourceData}`\n          break\n        case SourceType.Parent:\n          loadReason = `from module ${sourceData}`\n          break\n        case SourceType.Update:\n          loadReason = 'from an HMR update'\n          break\n        default:\n          invariant(\n            sourceType,\n            (sourceType) => `Unknown source type: ${sourceType}`\n          )\n      }\n      let error = new Error(\n        `Failed to load chunk ${chunkUrl} ${loadReason}${\n          cause ? `: ${cause}` : ''\n        }`,\n        cause ? { cause } : undefined\n      )\n      error.name = 'ChunkLoadError'\n      throw error\n    })\n    instrumentedBackendLoadChunks.set(thenable, entry)\n  }\n\n  return entry\n}\n\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkPath(\n  sourceType: SourceType,\n  sourceData: SourceData,\n  chunkPath: ChunkPath\n): Promise<void> {\n  const url = getChunkRelativeUrl(chunkPath)\n  return loadChunkByUrlInternal(sourceType, sourceData, url)\n}\n\n/**\n * Returns an absolute url to an asset.\n */\nfunction resolvePathFromModule(\n  this: TurbopackBaseContext<Module>,\n  moduleId: string\n): string {\n  const exported = this.r(moduleId)\n  return exported?.default ?? exported\n}\nbrowserContextPrototype.R = resolvePathFromModule\n\n/**\n * no-op for browser\n * @param modulePath\n */\nfunction resolveAbsolutePath(modulePath?: string): string {\n  return `/ROOT/${modulePath ?? ''}`\n}\nbrowserContextPrototype.P = resolveAbsolutePath\n\n/**\n * Returns a URL for the worker.\n * The entrypoint is a pre-compiled worker runtime file. The params configure\n * which module chunks to load and which module to run as the entry point.\n *\n * @param entrypoint URL path to the worker entrypoint chunk\n * @param moduleChunks list of module chunk paths to load\n * @param shared whether this is a SharedWorker (uses querystring for URL identity)\n */\nfunction getWorkerURL(\n  entrypoint: ChunkPath,\n  moduleChunks: ChunkPath[],\n  shared: boolean\n): URL {\n  const url = new URL(getChunkRelativeUrl(entrypoint), location.origin)\n\n  const params = {\n    S: CHUNK_SUFFIX,\n    N: (globalThis as any).NEXT_DEPLOYMENT_ID,\n    NC: moduleChunks.map((chunk) => getChunkRelativeUrl(chunk)),\n  }\n\n  const paramsJson = JSON.stringify(params)\n  if (shared) {\n    url.searchParams.set('params', paramsJson)\n  } else {\n    url.hash = '#params=' + encodeURIComponent(paramsJson)\n  }\n  return url\n}\nbrowserContextPrototype.b = getWorkerURL\n\n/**\n * Instantiates a runtime module.\n */\nfunction instantiateRuntimeModule(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): Module {\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n/**\n * Returns the URL relative to the origin where a chunk can be fetched from.\n */\nfunction getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {\n  return `${CHUNK_BASE_PATH}${chunkPath\n    .split('/')\n    .map((p) => encodeURIComponent(p))\n    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl\n}\n\n/**\n * Return the ChunkPath from a ChunkScript.\n */\nfunction getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath\nfunction getPathFromScript(\n  chunkScript: ChunkListPath | ChunkListScript\n): ChunkListPath\nfunction getPathFromScript(\n  chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript\n): ChunkPath | ChunkListPath {\n  if (typeof chunkScript === 'string') {\n    return chunkScript as ChunkPath | ChunkListPath\n  }\n  const chunkUrl =\n    typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined'\n      ? TURBOPACK_NEXT_CHUNK_URLS.pop()!\n      : chunkScript.getAttribute('src')!\n  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))\n  const path = src.startsWith(CHUNK_BASE_PATH)\n    ? src.slice(CHUNK_BASE_PATH.length)\n    : src\n  return path as ChunkPath | ChunkListPath\n}\n\nconst regexJsUrl = /\\.js(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.\n */\nfunction isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {\n  return regexJsUrl.test(chunkUrlOrPath)\n}\n\nconst regexCssUrl = /\\.css(?:\\?[^#]*)?(?:#.*)?$/\n/**\n * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.\n */\nfunction isCss(chunkUrl: ChunkUrl): boolean {\n  return regexCssUrl.test(chunkUrl)\n}\n\nfunction loadWebAssembly(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module,\n  importsObj: WebAssembly.Imports\n): Promise<Exports> {\n  return BACKEND.loadWebAssembly(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule,\n    importsObj\n  )\n}\ncontextPrototype.w = loadWebAssembly\n\nfunction loadWebAssemblyModule(\n  this: TurbopackBaseContext<Module>,\n  chunkPath: ChunkPath,\n  edgeModule: () => WebAssembly.Module\n): Promise<WebAssembly.Module> {\n  return BACKEND.loadWebAssemblyModule(\n    SourceType.Parent,\n    this.m.id,\n    chunkPath,\n    edgeModule\n  )\n}\ncontextPrototype.u = loadWebAssemblyModule\n"],"names":["browserContextPrototype","Context","prototype","SourceType","moduleFactories","Map","contextPrototype","M","availableModules","availableModuleChunks","factoryNotAvailableMessage","moduleId","sourceType","sourceData","instantiationReason","invariant","loadChunk","chunkData","loadChunkInternal","m","id","l","loadInitialChunk","chunkPath","loadChunkPath","includedList","included","modulesPromises","map","has","get","length","every","p","Promise","all","includedModuleChunksList","moduleChunks","moduleChunksPromises","filter","promise","moduleChunksToLoad","Set","moduleChunk","add","moduleChunkToLoad","set","push","path","includedModuleChunk","loadedChunk","resolve","undefined","instrumentedBackendLoadChunks","WeakMap","loadChunkByUrl","chunkUrl","loadChunkByUrlInternal","L","thenable","BACKEND","loadChunkCached","entry","bind","then","catch","cause","loadReason","error","Error","name","url","getChunkRelativeUrl","resolvePathFromModule","exported","r","default","R","resolveAbsolutePath","modulePath","P","getWorkerURL","entrypoint","shared","URL","location","origin","params","S","CHUNK_SUFFIX","N","globalThis","NEXT_DEPLOYMENT_ID","NC","chunk","paramsJson","JSON","stringify","searchParams","hash","encodeURIComponent","b","instantiateRuntimeModule","instantiateModule","CHUNK_BASE_PATH","split","join","getPathFromScript","chunkScript","TURBOPACK_NEXT_CHUNK_URLS","pop","getAttribute","src","decodeURIComponent","replace","startsWith","slice","regexJsUrl","isJs","chunkUrlOrPath","test","regexCssUrl","isCss","loadWebAssembly","edgeModule","importsObj","w","loadWebAssemblyModule","u"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 747, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// <reference path=\"./dev-globals.d.ts\" />\n/// <reference path=\"./dev-protocol.d.ts\" />\n/// <reference path=\"./dev-extensions.ts\" />\n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext<HotModule> {\n  k: RefreshContext\n}\n\nconst devContextPrototype = Context.prototype as TurbopackDevContext\n\n/**\n * This file contains runtime types and functions that are shared between all\n * Turbopack *development* ECMAScript runtimes.\n *\n * It will be appended to the runtime code of each runtime right after the\n * shared runtime utils.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\nconst devModuleCache: ModuleCache<HotModule> = Object.create(null)\ndevContextPrototype.c = devModuleCache\n\n// This file must not use `import` and `export` statements. Otherwise, it\n// becomes impossible to augment interfaces declared in `<reference>`d files\n// (e.g. `Module`). Hence, the need for `import()` here.\ntype RefreshRuntimeGlobals =\n  import('@next/react-refresh-utils/dist/runtime').RefreshRuntimeGlobals\n\ndeclare var $RefreshHelpers$: RefreshRuntimeGlobals['$RefreshHelpers$']\ndeclare var $RefreshReg$: RefreshRuntimeGlobals['$RefreshReg$']\ndeclare var $RefreshSig$: RefreshRuntimeGlobals['$RefreshSig$']\ndeclare var $RefreshInterceptModuleExecution$: RefreshRuntimeGlobals['$RefreshInterceptModuleExecution$']\n\ntype RefreshContext = {\n  register: RefreshRuntimeGlobals['$RefreshReg$']\n  signature: RefreshRuntimeGlobals['$RefreshSig$']\n  registerExports: typeof registerExportsAndSetupBoundaryForReactRefresh\n}\n\ntype RefreshHelpers = RefreshRuntimeGlobals['$RefreshHelpers$']\n\ntype ModuleFactory = (\n  this: Module['exports'],\n  context: TurbopackDevContext\n) => unknown\n\ninterface DevRuntimeBackend {\n  reloadChunk?: (chunkUrl: ChunkUrl) => Promise<void>\n  unloadChunk?: (chunkUrl: ChunkUrl) => void\n  restart: () => void\n}\n\nclass UpdateApplyError extends Error {\n  name = 'UpdateApplyError'\n\n  dependencyChain: ModuleId[]\n\n  constructor(message: string, dependencyChain: ModuleId[]) {\n    super(message)\n    this.dependencyChain = dependencyChain\n  }\n}\n\n/**\n * Module IDs that are instantiated as part of the runtime of a chunk.\n */\nconst runtimeModules: Set<ModuleId> = new Set()\n\n/**\n * Map from module ID to the chunks that contain this module.\n *\n * In HMR, we need to keep track of which modules are contained in which so\n * chunks. This is so we don't eagerly dispose of a module when it is removed\n * from chunk A, but still exists in chunk B.\n */\nconst moduleChunksMap: Map<ModuleId, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map<ChunkPath, Set<ModuleId>> = new Map()\n/**\n * Chunk lists that contain a runtime. When these chunk lists receive an update\n * that can't be reconciled with the current state of the page, we need to\n * reload the runtime entirely.\n */\nconst runtimeChunkLists: Set<ChunkListPath> = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map<ChunkListPath, Set<ChunkPath>> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()\n\n/**\n * Maps module IDs to persisted data between executions of their hot module\n * implementation (`hot.data`).\n */\nconst moduleHotData: Map<ModuleId, HotData> = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map<Module, HotState> = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set<ModuleId> = new Set()\n\n/**\n * Gets or instantiates a runtime module.\n */\n// @ts-ignore\nfunction getOrInstantiateRuntimeModule(\n  chunkPath: ChunkPath,\n  moduleId: ModuleId\n): Module {\n  const module = devModuleCache[moduleId]\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n    return module\n  }\n\n  // @ts-ignore\n  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)\n}\n\n/**\n * Retrieves a module from the cache, or instantiate it if it is not cached.\n */\n// @ts-ignore Defined in `runtime-utils.ts`\nconst getOrInstantiateModuleFromParent: GetOrInstantiateModuleFromParent<\n  HotModule\n> = (id, sourceModule) => {\n  if (!sourceModule.hot.active) {\n    console.warn(\n      `Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`\n    )\n  }\n\n  const module = devModuleCache[id]\n\n  if (sourceModule.children.indexOf(id) === -1) {\n    sourceModule.children.push(id)\n  }\n\n  if (module) {\n    if (module.error) {\n      throw module.error\n    }\n\n    if (module.parents.indexOf(sourceModule.id) === -1) {\n      module.parents.push(sourceModule.id)\n    }\n\n    return module\n  }\n\n  return instantiateModule(id, SourceType.Parent, sourceModule.id)\n}\n\nfunction DevContext(\n  this: TurbopackDevContext,\n  module: HotModule,\n  exports: Exports,\n  refresh: RefreshContext\n) {\n  Context.call(this, module, exports)\n  this.k = refresh\n}\nDevContext.prototype = Context.prototype\n\ntype DevContextConstructor = {\n  new (\n    module: HotModule,\n    exports: Exports,\n    refresh: RefreshContext\n  ): TurbopackDevContext\n}\n\nfunction instantiateModule(\n  moduleId: ModuleId,\n  sourceType: SourceType,\n  sourceData: SourceData\n): Module {\n  // We are in development, this is always a string.\n  let id = moduleId as string\n\n  const moduleFactory = moduleFactories.get(id)\n  if (typeof moduleFactory !== 'function') {\n    // This can happen if modules incorrectly handle HMR disposes/updates,\n    // e.g. when they keep a `setTimeout` around which still executes old code\n    // and contains e.g. a `require(\"something\")` call.\n    throw new Error(\n      factoryNotAvailableMessage(id, sourceType, sourceData) +\n        ' It might have been deleted in an HMR update.'\n    )\n  }\n\n  const hotData = moduleHotData.get(id)!\n  const { hot, hotState } = createModuleHot(id, hotData)\n\n  let parents: ModuleId[]\n  switch (sourceType) {\n    case SourceType.Runtime:\n      runtimeModules.add(id)\n      parents = []\n      break\n    case SourceType.Parent:\n      // No need to add this module as a child of the parent module here, this\n      // has already been taken care of in `getOrInstantiateModuleFromParent`.\n      parents = [sourceData as ModuleId]\n      break\n    case SourceType.Update:\n      parents = (sourceData as ModuleId[]) || []\n      break\n    default:\n      invariant(\n        sourceType,\n        (sourceType) => `Unknown source type: ${sourceType}`\n      )\n  }\n\n  const module: HotModule = createModuleObject(id) as HotModule\n  const exports = module.exports\n  module.parents = parents\n  module.children = []\n  module.hot = hot\n\n  devModuleCache[id] = module\n  moduleHotState.set(module, hotState)\n\n  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.\n  try {\n    runModuleExecutionHooks(module, (refresh) => {\n      const context = new (DevContext as any as DevContextConstructor)(\n        module,\n        exports,\n        refresh\n      )\n      moduleFactory(context, module, exports)\n    })\n  } catch (error) {\n    module.error = error as any\n    throw error\n  }\n\n  if (module.namespaceObject && module.exports !== module.namespaceObject) {\n    // in case of a circular dependency: cjs1 -> esm2 -> cjs1\n    interopEsm(module.exports, module.namespaceObject)\n  }\n\n  return module\n}\n\nconst DUMMY_REFRESH_CONTEXT = {\n  register: (_type: unknown, _id: unknown) => {},\n  signature: () => (_type: unknown) => {},\n  registerExports: (_module: unknown, _helpers: unknown) => {},\n}\n\n/**\n * NOTE(alexkirsz) Webpack has a \"module execution\" interception hook that\n * Next.js' React Refresh runtime hooks into to add module context to the\n * refresh registry.\n */\nfunction runModuleExecutionHooks(\n  module: HotModule,\n  executeModule: (ctx: RefreshContext) => void\n) {\n  if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {\n    const cleanupReactRefreshIntercept =\n      globalThis.$RefreshInterceptModuleExecution$(module.id)\n    try {\n      executeModule({\n        register: globalThis.$RefreshReg$,\n        signature: globalThis.$RefreshSig$,\n        registerExports: registerExportsAndSetupBoundaryForReactRefresh,\n      })\n    } finally {\n      // Always cleanup the intercept, even if module execution failed.\n      cleanupReactRefreshIntercept()\n    }\n  } else {\n    // If the react refresh hooks are not installed we need to bind dummy functions.\n    // This is expected when running in a Web Worker.  It is also common in some of\n    // our test environments.\n    executeModule(DUMMY_REFRESH_CONTEXT)\n  }\n}\n\n/**\n * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts\n */\nfunction registerExportsAndSetupBoundaryForReactRefresh(\n  module: HotModule,\n  helpers: RefreshHelpers\n) {\n  const currentExports = module.exports\n  const prevExports = module.hot.data.prevExports ?? null\n\n  helpers.registerExportsForReactRefresh(currentExports, module.id)\n\n  // A module can be accepted automatically based on its exports, e.g. when\n  // it is a Refresh Boundary.\n  if (helpers.isReactRefreshBoundary(currentExports)) {\n    // Save the previous exports on update, so we can compare the boundary\n    // signatures.\n    module.hot.dispose((data) => {\n      data.prevExports = currentExports\n    })\n    // Unconditionally accept an update to this module, we'll check if it's\n    // still a Refresh Boundary later.\n    module.hot.accept()\n\n    // This field is set when the previous version of this module was a\n    // Refresh Boundary, letting us know we need to check for invalidation or\n    // enqueue an update.\n    if (prevExports !== null) {\n      // A boundary can become ineligible if its exports are incompatible\n      // with the previous exports.\n      //\n      // For example, if you add/remove/change exports, we'll want to\n      // re-execute the importing modules, and force those components to\n      // re-render. Similarly, if you convert a class component to a\n      // function, we want to invalidate the boundary.\n      if (\n        helpers.shouldInvalidateReactRefreshBoundary(\n          helpers.getRefreshBoundarySignature(prevExports),\n          helpers.getRefreshBoundarySignature(currentExports)\n        )\n      ) {\n        module.hot.invalidate()\n      } else {\n        helpers.scheduleUpdate()\n      }\n    }\n  } else {\n    // Since we just executed the code for the module, it's possible that the\n    // new exports made it ineligible for being a boundary.\n    // We only care about the case when we were _previously_ a boundary,\n    // because we already accepted this update (accidental side effect).\n    const isNoLongerABoundary = prevExports !== null\n    if (isNoLongerABoundary) {\n      module.hot.invalidate()\n    }\n  }\n}\n\nfunction formatDependencyChain(dependencyChain: ModuleId[]): string {\n  return `Dependency chain: ${dependencyChain.join(' -> ')}`\n}\n\nfunction computeOutdatedModules(\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>,\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n): {\n  outdatedModules: Set<ModuleId>\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n} {\n  const newModuleFactories = new Map<ModuleId, ModuleFactory>()\n\n  for (const [moduleId, entry] of added) {\n    if (entry != null) {\n      newModuleFactories.set(moduleId, _eval(entry))\n    }\n  }\n\n  const outdatedModules = computedInvalidatedModules(modified.keys())\n\n  for (const [moduleId, entry] of modified) {\n    newModuleFactories.set(moduleId, _eval(entry))\n  }\n\n  return { outdatedModules, newModuleFactories }\n}\n\nfunction computedInvalidatedModules(\n  invalidated: Iterable<ModuleId>\n): Set<ModuleId> {\n  const outdatedModules = new Set<ModuleId>()\n\n  for (const moduleId of invalidated) {\n    const effect = getAffectedModuleEffects(moduleId)\n\n    switch (effect.type) {\n      case 'unaccepted':\n        throw new UpdateApplyError(\n          `cannot apply update: unaccepted module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'self-declined':\n        throw new UpdateApplyError(\n          `cannot apply update: self-declined module. ${formatDependencyChain(\n            effect.dependencyChain\n          )}.`,\n          effect.dependencyChain\n        )\n      case 'accepted':\n        for (const outdatedModuleId of effect.outdatedModules) {\n          outdatedModules.add(outdatedModuleId)\n        }\n        break\n      // TODO(alexkirsz) Dependencies: handle dependencies effects.\n      default:\n        invariant(effect, (effect) => `Unknown effect type: ${effect?.type}`)\n    }\n  }\n\n  return outdatedModules\n}\n\nfunction computeOutdatedSelfAcceptedModules(\n  outdatedModules: Iterable<ModuleId>\n): { moduleId: ModuleId; errorHandler: true | Function }[] {\n  const outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[] = []\n  for (const moduleId of outdatedModules) {\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n    if (module && hotState.selfAccepted && !hotState.selfInvalidated) {\n      outdatedSelfAcceptedModules.push({\n        moduleId,\n        errorHandler: hotState.selfAccepted,\n      })\n    }\n  }\n  return outdatedSelfAcceptedModules\n}\n\n/**\n * Adds, deletes, and moves modules between chunks. This must happen before the\n * dispose phase as it needs to know which modules were removed from all chunks,\n * which we can only compute *after* taking care of added and moved modules.\n */\nfunction updateChunksPhase(\n  chunksAddedModules: Map<ChunkPath, Set<ModuleId>>,\n  chunksDeletedModules: Map<ChunkPath, Set<ModuleId>>\n): { disposedModules: Set<ModuleId> } {\n  for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n    for (const moduleId of addedModuleIds) {\n      addModuleToChunk(moduleId, chunkPath)\n    }\n  }\n\n  const disposedModules: Set<ModuleId> = new Set()\n  for (const [chunkPath, addedModuleIds] of chunksDeletedModules) {\n    for (const moduleId of addedModuleIds) {\n      if (removeModuleFromChunk(moduleId, chunkPath)) {\n        disposedModules.add(moduleId)\n      }\n    }\n  }\n\n  return { disposedModules }\n}\n\nfunction disposePhase(\n  outdatedModules: Iterable<ModuleId>,\n  disposedModules: Iterable<ModuleId>\n): { outdatedModuleParents: Map<ModuleId, Array<ModuleId>> } {\n  for (const moduleId of outdatedModules) {\n    disposeModule(moduleId, 'replace')\n  }\n\n  for (const moduleId of disposedModules) {\n    disposeModule(moduleId, 'clear')\n  }\n\n  // Removing modules from the module cache is a separate step.\n  // We also want to keep track of previous parents of the outdated modules.\n  const outdatedModuleParents = new Map()\n  for (const moduleId of outdatedModules) {\n    const oldModule = devModuleCache[moduleId]\n    outdatedModuleParents.set(moduleId, oldModule?.parents)\n    delete devModuleCache[moduleId]\n  }\n\n  // TODO(alexkirsz) Dependencies: remove outdated dependency from module\n  // children.\n\n  return { outdatedModuleParents }\n}\n\n/**\n * Disposes of an instance of a module.\n *\n * Returns the persistent hot data that should be kept for the next module\n * instance.\n *\n * NOTE: mode = \"replace\" will not remove modules from the devModuleCache\n * This must be done in a separate step afterwards.\n * This is important because all modules need to be disposed to update the\n * parent/child relationships before they are actually removed from the devModuleCache.\n * If this was done in this method, the following disposeModule calls won't find\n * the module from the module id in the cache.\n */\nfunction disposeModule(moduleId: ModuleId, mode: 'clear' | 'replace') {\n  const module = devModuleCache[moduleId]\n  if (!module) {\n    return\n  }\n\n  const hotState = moduleHotState.get(module)!\n  const data = {}\n\n  // Run the `hot.dispose` handler, if any, passing in the persistent\n  // `hot.data` object.\n  for (const disposeHandler of hotState.disposeHandlers) {\n    disposeHandler(data)\n  }\n\n  // This used to warn in `getOrInstantiateModuleFromParent` when a disposed\n  // module is still importing other modules.\n  module.hot.active = false\n\n  moduleHotState.delete(module)\n\n  // TODO(alexkirsz) Dependencies: delete the module from outdated deps.\n\n  // Remove the disposed module from its children's parent list.\n  // It will be added back once the module re-instantiates and imports its\n  // children again.\n  for (const childId of module.children) {\n    const child = devModuleCache[childId]\n    if (!child) {\n      continue\n    }\n\n    const idx = child.parents.indexOf(module.id)\n    if (idx >= 0) {\n      child.parents.splice(idx, 1)\n    }\n  }\n\n  switch (mode) {\n    case 'clear':\n      delete devModuleCache[module.id]\n      moduleHotData.delete(module.id)\n      break\n    case 'replace':\n      moduleHotData.set(module.id, data)\n      break\n    default:\n      invariant(mode, (mode) => `invalid mode: ${mode}`)\n  }\n}\n\nfunction applyPhase(\n  outdatedSelfAcceptedModules: {\n    moduleId: ModuleId\n    errorHandler: true | Function\n  }[],\n  newModuleFactories: Map<ModuleId, ModuleFactory>,\n  outdatedModuleParents: Map<ModuleId, Array<ModuleId>>,\n  reportError: (err: any) => void\n) {\n  // Update module factories.\n  for (const [moduleId, factory] of newModuleFactories.entries()) {\n    applyModuleFactoryName(factory)\n    moduleFactories.set(moduleId, factory)\n  }\n\n  // TODO(alexkirsz) Run new runtime entries here.\n\n  // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.\n\n  // Re-instantiate all outdated self-accepted modules.\n  for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules) {\n    try {\n      instantiateModule(\n        moduleId,\n        SourceType.Update,\n        outdatedModuleParents.get(moduleId)\n      )\n    } catch (err) {\n      if (typeof errorHandler === 'function') {\n        try {\n          errorHandler(err, { moduleId, module: devModuleCache[moduleId] })\n        } catch (err2) {\n          reportError(err2)\n          reportError(err)\n        }\n      } else {\n        reportError(err)\n      }\n    }\n  }\n}\n\nfunction applyUpdate(update: PartialUpdate) {\n  switch (update.type) {\n    case 'ChunkListUpdate':\n      applyChunkListUpdate(update)\n      break\n    default:\n      invariant(update, (update) => `Unknown update type: ${update.type}`)\n  }\n}\n\nfunction applyChunkListUpdate(update: ChunkListUpdate) {\n  if (update.merged != null) {\n    for (const merged of update.merged) {\n      switch (merged.type) {\n        case 'EcmascriptMergedUpdate':\n          applyEcmascriptMergedUpdate(merged)\n          break\n        default:\n          invariant(merged, (merged) => `Unknown merged type: ${merged.type}`)\n      }\n    }\n  }\n\n  if (update.chunks != null) {\n    for (const [chunkPath, chunkUpdate] of Object.entries(\n      update.chunks\n    ) as Array<[ChunkPath, ChunkUpdate]>) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      switch (chunkUpdate.type) {\n        case 'added':\n          BACKEND.loadChunkCached(SourceType.Update, chunkUrl)\n          break\n        case 'total':\n          DEV_BACKEND.reloadChunk?.(chunkUrl)\n          break\n        case 'deleted':\n          DEV_BACKEND.unloadChunk?.(chunkUrl)\n          break\n        case 'partial':\n          invariant(\n            chunkUpdate.instruction,\n            (instruction) =>\n              `Unknown partial instruction: ${JSON.stringify(instruction)}.`\n          )\n          break\n        default:\n          invariant(\n            chunkUpdate,\n            (chunkUpdate) => `Unknown chunk update type: ${chunkUpdate.type}`\n          )\n      }\n    }\n  }\n}\n\nfunction applyEcmascriptMergedUpdate(update: EcmascriptMergedUpdate) {\n  const { entries = {}, chunks = {} } = update\n  const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(\n    entries,\n    chunks\n  )\n  const { outdatedModules, newModuleFactories } = computeOutdatedModules(\n    added,\n    modified\n  )\n  const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted)\n\n  applyInternal(outdatedModules, disposedModules, newModuleFactories)\n}\n\nfunction applyInvalidatedModules(outdatedModules: Set<ModuleId>) {\n  if (queuedInvalidatedModules.size > 0) {\n    computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId) => {\n      outdatedModules.add(moduleId)\n    })\n\n    queuedInvalidatedModules.clear()\n  }\n\n  return outdatedModules\n}\n\nfunction applyInternal(\n  outdatedModules: Set<ModuleId>,\n  disposedModules: Iterable<ModuleId>,\n  newModuleFactories: Map<ModuleId, ModuleFactory>\n) {\n  outdatedModules = applyInvalidatedModules(outdatedModules)\n\n  const outdatedSelfAcceptedModules =\n    computeOutdatedSelfAcceptedModules(outdatedModules)\n\n  const { outdatedModuleParents } = disposePhase(\n    outdatedModules,\n    disposedModules\n  )\n\n  // we want to continue on error and only throw the error after we tried applying all updates\n  let error: any\n\n  function reportError(err: any) {\n    if (!error) error = err\n  }\n\n  applyPhase(\n    outdatedSelfAcceptedModules,\n    newModuleFactories,\n    outdatedModuleParents,\n    reportError\n  )\n\n  if (error) {\n    throw error\n  }\n\n  if (queuedInvalidatedModules.size > 0) {\n    applyInternal(new Set(), [], new Map())\n  }\n}\n\nfunction computeChangedModules(\n  entries: Record<ModuleId, EcmascriptModuleEntry>,\n  updates: Record<ChunkPath, EcmascriptMergedChunkUpdate>\n): {\n  added: Map<ModuleId, EcmascriptModuleEntry | undefined>\n  modified: Map<ModuleId, EcmascriptModuleEntry>\n  deleted: Set<ModuleId>\n  chunksAdded: Map<ChunkPath, Set<ModuleId>>\n  chunksDeleted: Map<ChunkPath, Set<ModuleId>>\n} {\n  const chunksAdded = new Map()\n  const chunksDeleted = new Map()\n  const added: Map<ModuleId, EcmascriptModuleEntry> = new Map()\n  const modified = new Map()\n  const deleted: Set<ModuleId> = new Set()\n\n  for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates) as Array<\n    [ChunkPath, EcmascriptMergedChunkUpdate]\n  >) {\n    switch (mergedChunkUpdate.type) {\n      case 'added': {\n        const updateAdded = new Set(mergedChunkUpdate.modules)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        break\n      }\n      case 'deleted': {\n        // We could also use `mergedChunkUpdate.modules` here.\n        const updateDeleted = new Set(chunkModulesMap.get(chunkPath))\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      case 'partial': {\n        const updateAdded = new Set(mergedChunkUpdate.added)\n        const updateDeleted = new Set(mergedChunkUpdate.deleted)\n        for (const moduleId of updateAdded) {\n          added.set(moduleId, entries[moduleId])\n        }\n        for (const moduleId of updateDeleted) {\n          deleted.add(moduleId)\n        }\n        chunksAdded.set(chunkPath, updateAdded)\n        chunksDeleted.set(chunkPath, updateDeleted)\n        break\n      }\n      default:\n        invariant(\n          mergedChunkUpdate,\n          (mergedChunkUpdate) =>\n            `Unknown merged chunk update type: ${mergedChunkUpdate.type}`\n        )\n    }\n  }\n\n  // If a module was added from one chunk and deleted from another in the same update,\n  // consider it to be modified, as it means the module was moved from one chunk to another\n  // AND has new code in a single update.\n  for (const moduleId of added.keys()) {\n    if (deleted.has(moduleId)) {\n      added.delete(moduleId)\n      deleted.delete(moduleId)\n    }\n  }\n\n  for (const [moduleId, entry] of Object.entries(entries)) {\n    // Modules that haven't been added to any chunk but have new code are considered\n    // to be modified.\n    // This needs to be under the previous loop, as we need it to get rid of modules\n    // that were added and deleted in the same update.\n    if (!added.has(moduleId)) {\n      modified.set(moduleId, entry)\n    }\n  }\n\n  return { added, deleted, modified, chunksAdded, chunksDeleted }\n}\n\ntype ModuleEffect =\n  | {\n      type: 'unaccepted'\n      dependencyChain: ModuleId[]\n    }\n  | {\n      type: 'self-declined'\n      dependencyChain: ModuleId[]\n      moduleId: ModuleId\n    }\n  | {\n      type: 'accepted'\n      moduleId: ModuleId\n      outdatedModules: Set<ModuleId>\n    }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n  const outdatedModules: Set<ModuleId> = new Set()\n\n  type QueueItem = { moduleId?: ModuleId; dependencyChain: ModuleId[] }\n\n  const queue: QueueItem[] = [\n    {\n      moduleId,\n      dependencyChain: [],\n    },\n  ]\n\n  let nextItem\n  while ((nextItem = queue.shift())) {\n    const { moduleId, dependencyChain } = nextItem\n\n    if (moduleId != null) {\n      if (outdatedModules.has(moduleId)) {\n        // Avoid infinite loops caused by cycles between modules in the dependency chain.\n        continue\n      }\n\n      outdatedModules.add(moduleId)\n    }\n\n    // We've arrived at the runtime of the chunk, which means that nothing\n    // else above can accept this update.\n    if (moduleId === undefined) {\n      return {\n        type: 'unaccepted',\n        dependencyChain,\n      }\n    }\n\n    const module = devModuleCache[moduleId]\n    const hotState = moduleHotState.get(module)!\n\n    if (\n      // The module is not in the cache. Since this is a \"modified\" update,\n      // it means that the module was never instantiated before.\n      !module || // The module accepted itself without invalidating globalThis.\n      // TODO is that right?\n      (hotState.selfAccepted && !hotState.selfInvalidated)\n    ) {\n      continue\n    }\n\n    if (hotState.selfDeclined) {\n      return {\n        type: 'self-declined',\n        dependencyChain,\n        moduleId,\n      }\n    }\n\n    if (runtimeModules.has(moduleId)) {\n      queue.push({\n        moduleId: undefined,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n      continue\n    }\n\n    for (const parentId of module.parents) {\n      const parent = devModuleCache[parentId]\n\n      if (!parent) {\n        // TODO(alexkirsz) Is this even possible?\n        continue\n      }\n\n      // TODO(alexkirsz) Dependencies: check accepted and declined\n      // dependencies here.\n\n      queue.push({\n        moduleId: parentId,\n        dependencyChain: [...dependencyChain, moduleId],\n      })\n    }\n  }\n\n  return {\n    type: 'accepted',\n    moduleId,\n    outdatedModules,\n  }\n}\n\nfunction handleApply(chunkListPath: ChunkListPath, update: ServerMessage) {\n  switch (update.type) {\n    case 'partial': {\n      // This indicates that the update is can be applied to the current state of the application.\n      applyUpdate(update.instruction)\n      break\n    }\n    case 'restart': {\n      // This indicates that there is no way to apply the update to the\n      // current state of the application, and that the application must be\n      // restarted.\n      DEV_BACKEND.restart()\n      break\n    }\n    case 'notFound': {\n      // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,\n      // or the page itself was deleted.\n      // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.\n      // If it is a runtime chunk list, we restart the application.\n      if (runtimeChunkLists.has(chunkListPath)) {\n        DEV_BACKEND.restart()\n      } else {\n        disposeChunkList(chunkListPath)\n      }\n      break\n    }\n    default:\n      throw new Error(`Unknown update type: ${update.type}`)\n  }\n}\n\nfunction createModuleHot(\n  moduleId: ModuleId,\n  hotData: HotData\n): { hot: Hot; hotState: HotState } {\n  const hotState: HotState = {\n    selfAccepted: false,\n    selfDeclined: false,\n    selfInvalidated: false,\n    disposeHandlers: [],\n  }\n\n  const hot: Hot = {\n    // TODO(alexkirsz) This is not defined in the HMR API. It was used to\n    // decide whether to warn whenever an HMR-disposed module required other\n    // modules. We might want to remove it.\n    active: true,\n\n    data: hotData ?? {},\n\n    // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.\n    accept: (\n      modules?: string | string[] | AcceptErrorHandler,\n      _callback?: AcceptCallback,\n      _errorHandler?: AcceptErrorHandler\n    ) => {\n      if (modules === undefined) {\n        hotState.selfAccepted = true\n      } else if (typeof modules === 'function') {\n        hotState.selfAccepted = modules\n      } else {\n        throw new Error('unsupported `accept` signature')\n      }\n    },\n\n    decline: (dep) => {\n      if (dep === undefined) {\n        hotState.selfDeclined = true\n      } else {\n        throw new Error('unsupported `decline` signature')\n      }\n    },\n\n    dispose: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    addDisposeHandler: (callback) => {\n      hotState.disposeHandlers.push(callback)\n    },\n\n    removeDisposeHandler: (callback) => {\n      const idx = hotState.disposeHandlers.indexOf(callback)\n      if (idx >= 0) {\n        hotState.disposeHandlers.splice(idx, 1)\n      }\n    },\n\n    invalidate: () => {\n      hotState.selfInvalidated = true\n      queuedInvalidatedModules.add(moduleId)\n    },\n\n    // NOTE(alexkirsz) This is part of the management API, which we don't\n    // implement, but the Next.js React Refresh runtime uses this to decide\n    // whether to schedule an update.\n    status: () => 'idle',\n\n    // NOTE(alexkirsz) Since we always return \"idle\" for now, these are no-ops.\n    addStatusHandler: (_handler) => {},\n    removeStatusHandler: (_handler) => {},\n\n    // NOTE(jridgewell) Check returns the list of updated modules, but we don't\n    // want the webpack code paths to ever update (the turbopack paths handle\n    // this already).\n    check: () => Promise.resolve(null),\n  }\n\n  return { hot, hotState }\n}\n\n/**\n * Removes a module from a chunk.\n * Returns `true` if there are no remaining chunks including this module.\n */\nfunction removeModuleFromChunk(\n  moduleId: ModuleId,\n  chunkPath: ChunkPath\n): boolean {\n  const moduleChunks = moduleChunksMap.get(moduleId)!\n  moduleChunks.delete(chunkPath)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)!\n  chunkModules.delete(moduleId)\n\n  const noRemainingModules = chunkModules.size === 0\n  if (noRemainingModules) {\n    chunkModulesMap.delete(chunkPath)\n  }\n\n  const noRemainingChunks = moduleChunks.size === 0\n  if (noRemainingChunks) {\n    moduleChunksMap.delete(moduleId)\n  }\n\n  return noRemainingChunks\n}\n\n/**\n * Disposes of a chunk list and its corresponding exclusive chunks.\n */\nfunction disposeChunkList(chunkListPath: ChunkListPath): boolean {\n  const chunkPaths = chunkListChunksMap.get(chunkListPath)\n  if (chunkPaths == null) {\n    return false\n  }\n  chunkListChunksMap.delete(chunkListPath)\n\n  for (const chunkPath of chunkPaths) {\n    const chunkChunkLists = chunkChunkListsMap.get(chunkPath)!\n    chunkChunkLists.delete(chunkListPath)\n\n    if (chunkChunkLists.size === 0) {\n      chunkChunkListsMap.delete(chunkPath)\n      disposeChunk(chunkPath)\n    }\n  }\n\n  // We must also dispose of the chunk list's chunk itself to ensure it may\n  // be reloaded properly in the future.\n  const chunkListUrl = getChunkRelativeUrl(chunkListPath)\n\n  DEV_BACKEND.unloadChunk?.(chunkListUrl)\n\n  return true\n}\n\n/**\n * Disposes of a chunk and its corresponding exclusive modules.\n *\n * @returns Whether the chunk was disposed of.\n */\nfunction disposeChunk(chunkPath: ChunkPath): boolean {\n  const chunkUrl = getChunkRelativeUrl(chunkPath)\n  // This should happen whether the chunk has any modules in it or not.\n  // For instance, CSS chunks have no modules in them, but they still need to be unloaded.\n  DEV_BACKEND.unloadChunk?.(chunkUrl)\n\n  const chunkModules = chunkModulesMap.get(chunkPath)\n  if (chunkModules == null) {\n    return false\n  }\n  chunkModules.delete(chunkPath)\n\n  for (const moduleId of chunkModules) {\n    const moduleChunks = moduleChunksMap.get(moduleId)!\n    moduleChunks.delete(chunkPath)\n\n    const noRemainingChunks = moduleChunks.size === 0\n    if (noRemainingChunks) {\n      moduleChunksMap.delete(moduleId)\n      disposeModule(moduleId, 'clear')\n      availableModules.delete(moduleId)\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a module to a chunk.\n */\nfunction addModuleToChunk(moduleId: ModuleId, chunkPath: ChunkPath) {\n  let moduleChunks = moduleChunksMap.get(moduleId)\n  if (!moduleChunks) {\n    moduleChunks = new Set([chunkPath])\n    moduleChunksMap.set(moduleId, moduleChunks)\n  } else {\n    moduleChunks.add(chunkPath)\n  }\n\n  let chunkModules = chunkModulesMap.get(chunkPath)\n  if (!chunkModules) {\n    chunkModules = new Set([moduleId])\n    chunkModulesMap.set(chunkPath, chunkModules)\n  } else {\n    chunkModules.add(moduleId)\n  }\n}\n\n/**\n * Marks a chunk list as a runtime chunk list. There can be more than one\n * runtime chunk list. For instance, integration tests can have multiple chunk\n * groups loaded at runtime, each with its own chunk list.\n */\nfunction markChunkListAsRuntime(chunkListPath: ChunkListPath) {\n  runtimeChunkLists.add(chunkListPath)\n}\n\nfunction registerChunk(registration: ChunkRegistration) {\n  const chunkPath = getPathFromScript(registration[0])\n  let runtimeParams: RuntimeParams | undefined\n  // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length\n  if (registration.length === 2) {\n    runtimeParams = registration[1] as RuntimeParams\n  } else {\n    runtimeParams = undefined\n    installCompressedModuleFactories(\n      registration as CompressedModuleFactories,\n      /* offset= */ 1,\n      moduleFactories,\n      (id: ModuleId) => addModuleToChunk(id, chunkPath)\n    )\n  }\n  return BACKEND.registerChunk(chunkPath, runtimeParams)\n}\n\n/**\n * Subscribes to chunk list updates from the update server and applies them.\n */\nfunction registerChunkList(chunkList: ChunkList) {\n  const chunkListScript = chunkList.script\n  const chunkListPath = getPathFromScript(chunkListScript)\n  // The \"chunk\" is also registered to finish the loading in the backend\n  BACKEND.registerChunk(chunkListPath as string as ChunkPath)\n  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([\n    chunkListPath,\n    handleApply.bind(null, chunkListPath),\n  ])\n\n  // Adding chunks to chunk lists and vice versa.\n  const chunkPaths = new Set(chunkList.chunks.map(getChunkPath))\n  chunkListChunksMap.set(chunkListPath, chunkPaths)\n  for (const chunkPath of chunkPaths) {\n    let chunkChunkLists = chunkChunkListsMap.get(chunkPath)\n    if (!chunkChunkLists) {\n      chunkChunkLists = new Set([chunkListPath])\n      chunkChunkListsMap.set(chunkPath, chunkChunkLists)\n    } else {\n      chunkChunkLists.add(chunkListPath)\n    }\n  }\n\n  if (chunkList.source === 'entry') {\n    markChunkListAsRuntime(chunkListPath)\n  }\n}\n\nglobalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= []\n"],"names":["devContextPrototype","Context","prototype","devModuleCache","Object","create","c","UpdateApplyError","Error","name","dependencyChain","message","runtimeModules","Set","moduleChunksMap","Map","chunkModulesMap","runtimeChunkLists","chunkListChunksMap","chunkChunkListsMap","moduleHotData","moduleHotState","queuedInvalidatedModules","getOrInstantiateRuntimeModule","chunkPath","moduleId","module","error","instantiateModule","SourceType","Runtime","getOrInstantiateModuleFromParent","id","sourceModule","hot","active","console","warn","children","indexOf","push","parents","Parent","DevContext","exports","refresh","call","k","sourceType","sourceData","moduleFactory","moduleFactories","get","factoryNotAvailableMessage","hotData","hotState","createModuleHot","add","Update","invariant","createModuleObject","set","runModuleExecutionHooks","context","namespaceObject","interopEsm","DUMMY_REFRESH_CONTEXT","register","_type","_id","signature","registerExports","_module","_helpers","executeModule","globalThis","$RefreshInterceptModuleExecution$","cleanupReactRefreshIntercept","$RefreshReg$","$RefreshSig$","registerExportsAndSetupBoundaryForReactRefresh","helpers","currentExports","prevExports","data","registerExportsForReactRefresh","isReactRefreshBoundary","dispose","accept","shouldInvalidateReactRefreshBoundary","getRefreshBoundarySignature","invalidate","scheduleUpdate","isNoLongerABoundary","formatDependencyChain","join","computeOutdatedModules","added","modified","newModuleFactories","entry","_eval","outdatedModules","computedInvalidatedModules","keys","invalidated","effect","getAffectedModuleEffects","type","outdatedModuleId","computeOutdatedSelfAcceptedModules","outdatedSelfAcceptedModules","selfAccepted","selfInvalidated","errorHandler","updateChunksPhase","chunksAddedModules","chunksDeletedModules","addedModuleIds","addModuleToChunk","disposedModules","removeModuleFromChunk","disposePhase","disposeModule","outdatedModuleParents","oldModule","mode","disposeHandler","disposeHandlers","delete","childId","child","idx","splice","applyPhase","reportError","factory","entries","applyModuleFactoryName","err","err2","applyUpdate","update","applyChunkListUpdate","merged","applyEcmascriptMergedUpdate","chunks","chunkUpdate","chunkUrl","getChunkRelativeUrl","BACKEND","loadChunkCached","DEV_BACKEND","reloadChunk","unloadChunk","instruction","JSON","stringify","chunksAdded","chunksDeleted","computeChangedModules","applyInternal","applyInvalidatedModules","size","forEach","clear","updates","deleted","mergedChunkUpdate","updateAdded","modules","updateDeleted","has","queue","nextItem","shift","undefined","selfDeclined","parentId","parent","handleApply","chunkListPath","restart","disposeChunkList","_callback","_errorHandler","decline","dep","callback","addDisposeHandler","removeDisposeHandler","status","addStatusHandler","_handler","removeStatusHandler","check","Promise","resolve","moduleChunks","chunkModules","noRemainingModules","noRemainingChunks","chunkPaths","chunkChunkLists","disposeChunk","chunkListUrl","availableModules","markChunkListAsRuntime","registerChunk","registration","getPathFromScript","runtimeParams","length","installCompressedModuleFactories","registerChunkList","chunkList","chunkListScript","script","TURBOPACK_CHUNK_UPDATE_LISTENERS","bind","map","getChunkPath","source"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1601, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/runtime-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.\n *\n * It will be appended to the base runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../../../browser/runtime/base/runtime-base.ts\" />\n/// <reference path=\"../../../shared/runtime-types.d.ts\" />\n\nfunction getChunkSuffixFromScriptSrc() {\n  // TURBOPACK_CHUNK_SUFFIX is set in web workers\n  return (\n    (self.TURBOPACK_CHUNK_SUFFIX ??\n      document?.currentScript\n        ?.getAttribute?.('src')\n        ?.replace(/^(.*(?=\\?)|^.*$)/, '')) ||\n    ''\n  )\n}\n\ntype ChunkResolver = {\n  resolved: boolean\n  loadingStarted: boolean\n  resolve: () => void\n  reject: (error?: Error) => void\n  promise: Promise<any>\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()\n\n;(() => {\n  BACKEND = {\n    async registerChunk(chunkPath, params) {\n      const chunkUrl = getChunkRelativeUrl(chunkPath)\n\n      const resolver = getOrCreateResolver(chunkUrl)\n      resolver.resolve()\n\n      if (params == null) {\n        return\n      }\n\n      for (const otherChunkData of params.otherChunks) {\n        const otherChunkPath = getChunkPath(otherChunkData)\n        const otherChunkUrl = getChunkRelativeUrl(otherChunkPath)\n\n        // Chunk might have started loading, so we want to avoid triggering another load.\n        getOrCreateResolver(otherChunkUrl)\n      }\n\n      // This waits for chunks to be loaded, but also marks included items as available.\n      await Promise.all(\n        params.otherChunks.map((otherChunkData) =>\n          loadInitialChunk(chunkPath, otherChunkData)\n        )\n      )\n\n      if (params.runtimeModuleIds.length > 0) {\n        for (const moduleId of params.runtimeModuleIds) {\n          getOrInstantiateRuntimeModule(chunkPath, moduleId)\n        }\n      }\n    },\n\n    /**\n     * Loads the given chunk, and returns a promise that resolves once the chunk\n     * has been loaded.\n     */\n    loadChunkCached(sourceType: SourceType, chunkUrl: ChunkUrl) {\n      return doLoadChunk(sourceType, chunkUrl)\n    },\n\n    async loadWebAssembly(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module,\n      importsObj: WebAssembly.Imports\n    ): Promise<Exports> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      const { instance } = await WebAssembly.instantiateStreaming(\n        req,\n        importsObj\n      )\n\n      return instance.exports\n    },\n\n    async loadWebAssemblyModule(\n      _sourceType: SourceType,\n      _sourceData: SourceData,\n      wasmChunkPath: ChunkPath,\n      _edgeModule: () => WebAssembly.Module\n    ): Promise<WebAssembly.Module> {\n      const req = fetchWebAssembly(wasmChunkPath)\n\n      return await WebAssembly.compileStreaming(req)\n    },\n  }\n\n  function getOrCreateResolver(chunkUrl: ChunkUrl): ChunkResolver {\n    let resolver = chunkResolvers.get(chunkUrl)\n    if (!resolver) {\n      let resolve: () => void\n      let reject: (error?: Error) => void\n      const promise = new Promise<void>((innerResolve, innerReject) => {\n        resolve = innerResolve\n        reject = innerReject\n      })\n      resolver = {\n        resolved: false,\n        loadingStarted: false,\n        promise,\n        resolve: () => {\n          resolver!.resolved = true\n          resolve()\n        },\n        reject: reject!,\n      }\n      chunkResolvers.set(chunkUrl, resolver)\n    }\n    return resolver\n  }\n\n  /**\n   * Loads the given chunk, and returns a promise that resolves once the chunk\n   * has been loaded.\n   */\n  function doLoadChunk(sourceType: SourceType, chunkUrl: ChunkUrl) {\n    const resolver = getOrCreateResolver(chunkUrl)\n    if (resolver.loadingStarted) {\n      return resolver.promise\n    }\n\n    if (sourceType === SourceType.Runtime) {\n      // We don't need to load chunks references from runtime code, as they're already\n      // present in the DOM.\n      resolver.loadingStarted = true\n\n      if (isCss(chunkUrl)) {\n        // CSS chunks do not register themselves, and as such must be marked as\n        // loaded instantly.\n        resolver.resolve()\n      }\n\n      // We need to wait for JS chunks to register themselves within `registerChunk`\n      // before we can start instantiating runtime modules, hence the absence of\n      // `resolver.resolve()` in this branch.\n\n      return resolver.promise\n    }\n\n    if (typeof importScripts === 'function') {\n      // We're in a web worker\n      if (isCss(chunkUrl)) {\n        // ignore\n      } else if (isJs(chunkUrl)) {\n        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl)\n        importScripts(chunkUrl)\n      } else {\n        throw new Error(\n          `can't infer type of chunk from URL ${chunkUrl} in worker`\n        )\n      }\n    } else {\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousLinks.length > 0) {\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolver.resolve()\n        } else {\n          const link = document.createElement('link')\n          link.rel = 'stylesheet'\n          link.href = chunkUrl\n          link.onerror = () => {\n            resolver.reject()\n          }\n          link.onload = () => {\n            // CSS chunks do not register themselves, and as such must be marked as\n            // loaded instantly.\n            resolver.resolve()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(link)\n        }\n      } else if (isJs(chunkUrl)) {\n        const previousScripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        if (previousScripts.length > 0) {\n          // There is this edge where the script already failed loading, but we\n          // can't detect that. The Promise will never resolve in this case.\n          for (const script of Array.from(previousScripts)) {\n            script.addEventListener('error', () => {\n              resolver.reject()\n            })\n          }\n        } else {\n          const script = document.createElement('script')\n          script.src = chunkUrl\n          // We'll only mark the chunk as loaded once the script has been executed,\n          // which happens in `registerChunk`. Hence the absence of `resolve()` in\n          // this branch.\n          script.onerror = () => {\n            resolver.reject()\n          }\n          // Append to the `head` for webpack compatibility.\n          document.head.appendChild(script)\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    }\n\n    resolver.loadingStarted = true\n    return resolver.promise\n  }\n\n  function fetchWebAssembly(wasmChunkPath: ChunkPath) {\n    return fetch(getChunkRelativeUrl(wasmChunkPath))\n  }\n})()\n"],"names":["getChunkSuffixFromScriptSrc","self","TURBOPACK_CHUNK_SUFFIX","document","currentScript","getAttribute","replace","BACKEND","chunkResolvers","Map","registerChunk","chunkPath","params","chunkUrl","getChunkRelativeUrl","resolver","getOrCreateResolver","resolve","otherChunkData","otherChunks","otherChunkPath","getChunkPath","otherChunkUrl","Promise","all","map","loadInitialChunk","runtimeModuleIds","length","moduleId","getOrInstantiateRuntimeModule","loadChunkCached","sourceType","doLoadChunk","loadWebAssembly","_sourceType","_sourceData","wasmChunkPath","_edgeModule","importsObj","req","fetchWebAssembly","instance","WebAssembly","instantiateStreaming","exports","loadWebAssemblyModule","compileStreaming","get","reject","promise","innerResolve","innerReject","resolved","loadingStarted","set","SourceType","Runtime","isCss","importScripts","isJs","TURBOPACK_NEXT_CHUNK_URLS","push","Error","decodedChunkUrl","decodeURI","previousLinks","querySelectorAll","link","createElement","rel","href","onerror","onload","head","appendChild","previousScripts","script","Array","from","addEventListener","src","fetch"],"mappings":"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","ignoreList":[0]}},
+    {"offset": {"line": 1766, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/dom/dev-backend-dom.ts"],"sourcesContent":["/**\n * This file contains the runtime code specific to the Turbopack development\n * ECMAScript DOM runtime.\n *\n * It will be appended to the base development runtime code.\n */\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n/// <reference path=\"../base/runtime-base.ts\" />\n/// <reference path=\"../base/dev-base.ts\" />\n/// <reference path=\"./runtime-backend-dom.ts\" />\n/// <reference path=\"../../../shared/require-type.d.ts\" />\n\nlet DEV_BACKEND: DevRuntimeBackend\n;(() => {\n  DEV_BACKEND = {\n    unloadChunk(chunkUrl) {\n      deleteResolver(chunkUrl)\n\n      // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.\n      const decodedChunkUrl = decodeURI(chunkUrl)\n\n      if (isCss(chunkUrl)) {\n        const links = document.querySelectorAll(\n          `link[href=\"${chunkUrl}\"],link[href^=\"${chunkUrl}?\"],link[href=\"${decodedChunkUrl}\"],link[href^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const link of Array.from(links)) {\n          link.remove()\n        }\n      } else if (isJs(chunkUrl)) {\n        // Unloading a JS chunk would have no effect, as it lives in the JS\n        // runtime once evaluated.\n        // However, we still want to remove the script tag from the DOM to keep\n        // the HTML somewhat consistent from the user's perspective.\n        const scripts = document.querySelectorAll(\n          `script[src=\"${chunkUrl}\"],script[src^=\"${chunkUrl}?\"],script[src=\"${decodedChunkUrl}\"],script[src^=\"${decodedChunkUrl}?\"]`\n        )\n        for (const script of Array.from(scripts)) {\n          script.remove()\n        }\n      } else {\n        throw new Error(`can't infer type of chunk from URL ${chunkUrl}`)\n      }\n    },\n\n    reloadChunk(chunkUrl) {\n      return new Promise<void>((resolve, reject) => {\n        if (!isCss(chunkUrl)) {\n          reject(new Error('The DOM backend can only reload CSS chunks'))\n          return\n        }\n\n        const decodedChunkUrl = decodeURI(chunkUrl)\n        const previousLinks = document.querySelectorAll(\n          `link[rel=stylesheet][href=\"${chunkUrl}\"],link[rel=stylesheet][href^=\"${chunkUrl}?\"],link[rel=stylesheet][href=\"${decodedChunkUrl}\"],link[rel=stylesheet][href^=\"${decodedChunkUrl}?\"]`\n        )\n\n        if (previousLinks.length === 0) {\n          reject(new Error(`No link element found for chunk ${chunkUrl}`))\n          return\n        }\n\n        const link = document.createElement('link')\n        link.rel = 'stylesheet'\n\n        if (navigator.userAgent.includes('Firefox')) {\n          // Firefox won't reload CSS files that were previously loaded on the current page,\n          // we need to add a query param to make sure CSS is actually reloaded from the server.\n          //\n          // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506\n          //\n          // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag\n          // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726\n          link.href = `${chunkUrl}?ts=${Date.now()}`\n        } else {\n          link.href = chunkUrl\n        }\n\n        link.onerror = () => {\n          reject()\n        }\n        link.onload = () => {\n          // First load the new CSS, then remove the old ones. This prevents visible\n          // flickering that would happen in-between removing the previous CSS and\n          // loading the new one.\n          for (const previousLink of Array.from(previousLinks))\n            previousLink.remove()\n\n          // CSS chunks do not register themselves, and as such must be marked as\n          // loaded instantly.\n          resolve()\n        }\n\n        // Make sure to insert the new CSS right after the previous one, so that\n        // its precedence is higher.\n        previousLinks[0].parentElement!.insertBefore(\n          link,\n          previousLinks[0].nextSibling\n        )\n      })\n    },\n\n    restart: () => self.location.reload(),\n  }\n\n  function deleteResolver(chunkUrl: ChunkUrl) {\n    chunkResolvers.delete(chunkUrl)\n  }\n})()\n\nfunction _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {\n  code += `\\n\\n//# sourceURL=${encodeURI(\n    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX\n  )}`\n  if (map) {\n    code += `\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(\n      // btoa doesn't handle nonlatin characters, so escape them as \\x sequences\n      // See https://stackoverflow.com/a/26603875\n      unescape(encodeURIComponent(map))\n    )}`\n  }\n\n  // eslint-disable-next-line no-eval\n  return eval(code)\n}\n"],"names":["DEV_BACKEND","unloadChunk","chunkUrl","deleteResolver","decodedChunkUrl","decodeURI","isCss","links","document","querySelectorAll","link","Array","from","remove","isJs","scripts","script","Error","reloadChunk","Promise","resolve","reject","previousLinks","length","createElement","rel","navigator","userAgent","includes","href","Date","now","onerror","onload","previousLink","parentElement","insertBefore","nextSibling","restart","self","location","reload","chunkResolvers","delete","_eval","code","url","map","encodeURI","origin","CHUNK_BASE_PATH","CHUNK_SUFFIX","btoa","unescape","encodeURIComponent","eval"],"mappings":"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","ignoreList":[0]}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js
new file mode 100644
index 00000000000000..b5879a13666f77
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js
@@ -0,0 +1,8 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js",
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js [test] (ecmascript)", ((__turbopack_context__, module, exports) => {
+
+self.onconnect = (e)=>e.ports[0].postMessage('hello');
+}),
+]);
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js.map
new file mode 100644
index 00000000000000..4c9a7f2f98b33b
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js.map
@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 3, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js"],"sourcesContent":["self.onconnect = (e) => e.ports[0].postMessage('hello')\n"],"names":["self","onconnect","e","ports","postMessage"],"mappings":"AAAAA,KAAKC,SAAS,GAAG,CAACC,IAAMA,EAAEC,KAAK,CAAC,EAAE,CAACC,WAAW,CAAC"}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js
new file mode 100644
index 00000000000000..a8172d560c6463
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js
@@ -0,0 +1,1869 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([
+    "output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js",
+    {"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js [test] (ecmascript)"]}
+]);
+(() => {
+if (!Array.isArray(globalThis.TURBOPACK)) {
+    return;
+}
+
+const CHUNK_BASE_PATH = "";
+const RELATIVE_ROOT_PATH = "../../../../../../..";
+const RUNTIME_PUBLIC_PATH = "";
+const CHUNK_SUFFIX = "";
+/**
+ * This file contains runtime types and functions that are shared between all
+ * TurboPack ECMAScript runtimes.
+ *
+ * It will be prepended to the runtime code of each runtime.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
+const REEXPORTED_OBJECTS = new WeakMap();
+/**
+ * Constructs the `__turbopack_context__` object for a module.
+ */ function Context(module, exports) {
+    this.m = module;
+    // We need to store this here instead of accessing it from the module object to:
+    // 1. Make it available to factories directly, since we rewrite `this` to
+    //    `__turbopack_context__.e` in CJS modules.
+    // 2. Support async modules which rewrite `module.exports` to a promise, so we
+    //    can still access the original exports object from functions like
+    //    `esmExport`
+    // Ideally we could find a new approach for async modules and drop this property altogether.
+    this.e = exports;
+}
+const contextPrototype = Context.prototype;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+function defineProp(obj, name, options) {
+    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
+}
+function getOverwrittenModule(moduleCache, id) {
+    let module = moduleCache[id];
+    if (!module) {
+        // This is invoked when a module is merged into another module, thus it wasn't invoked via
+        // instantiateModule and the cache entry wasn't created yet.
+        module = createModuleObject(id);
+        moduleCache[id] = module;
+    }
+    return module;
+}
+/**
+ * Creates the module object. Only done here to ensure all module objects have the same shape.
+ */ function createModuleObject(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined
+    };
+}
+const BindingTag_Value = 0;
+/**
+ * Adds the getters to the exports object.
+ */ function esm(exports, bindings) {
+    defineProp(exports, '__esModule', {
+        value: true
+    });
+    if (toStringTag) defineProp(exports, toStringTag, {
+        value: 'Module'
+    });
+    let i = 0;
+    while(i < bindings.length){
+        const propName = bindings[i++];
+        const tagOrFunction = bindings[i++];
+        if (typeof tagOrFunction === 'number') {
+            if (tagOrFunction === BindingTag_Value) {
+                defineProp(exports, propName, {
+                    value: bindings[i++],
+                    enumerable: true,
+                    writable: false
+                });
+            } else {
+                throw new Error(`unexpected tag: ${tagOrFunction}`);
+            }
+        } else {
+            const getterFn = tagOrFunction;
+            if (typeof bindings[i] === 'function') {
+                const setterFn = bindings[i++];
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    set: setterFn,
+                    enumerable: true
+                });
+            } else {
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    enumerable: true
+                });
+            }
+        }
+    }
+    Object.seal(exports);
+}
+/**
+ * Makes the module an ESM with exports
+ */ function esmExport(bindings, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    module.namespaceObject = exports;
+    esm(exports, bindings);
+}
+contextPrototype.s = esmExport;
+function ensureDynamicExports(module, exports) {
+    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
+    if (!reexportedObjects) {
+        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
+        module.exports = module.namespaceObject = new Proxy(exports, {
+            get (target, prop) {
+                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
+                    return Reflect.get(target, prop);
+                }
+                for (const obj of reexportedObjects){
+                    const value = Reflect.get(obj, prop);
+                    if (value !== undefined) return value;
+                }
+                return undefined;
+            },
+            ownKeys (target) {
+                const keys = Reflect.ownKeys(target);
+                for (const obj of reexportedObjects){
+                    for (const key of Reflect.ownKeys(obj)){
+                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
+                    }
+                }
+                return keys;
+            }
+        });
+    }
+    return reexportedObjects;
+}
+/**
+ * Dynamically exports properties from an object
+ */ function dynamicExport(object, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    const reexportedObjects = ensureDynamicExports(module, exports);
+    if (typeof object === 'object' && object !== null) {
+        reexportedObjects.push(object);
+    }
+}
+contextPrototype.j = dynamicExport;
+function exportValue(value, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = value;
+}
+contextPrototype.v = exportValue;
+function exportNamespace(namespace, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = module.namespaceObject = namespace;
+}
+contextPrototype.n = exportNamespace;
+function createGetter(obj, key) {
+    return ()=>obj[key];
+}
+/**
+ * @returns prototype of the object
+ */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
+    null,
+    getProto({}),
+    getProto([]),
+    getProto(getProto)
+];
+/**
+ * @param raw
+ * @param ns
+ * @param allowExportDefault
+ *   * `false`: will have the raw module as default export
+ *   * `true`: will have the default property as default export
+ */ function interopEsm(raw, ns, allowExportDefault) {
+    const bindings = [];
+    let defaultLocation = -1;
+    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
+        for (const key of Object.getOwnPropertyNames(current)){
+            bindings.push(key, createGetter(raw, key));
+            if (defaultLocation === -1 && key === 'default') {
+                defaultLocation = bindings.length - 1;
+            }
+        }
+    }
+    // this is not really correct
+    // we should set the `default` getter if the imported module is a `.cjs file`
+    if (!(allowExportDefault && defaultLocation >= 0)) {
+        // Replace the binding with one for the namespace itself in order to preserve iteration order.
+        if (defaultLocation >= 0) {
+            // Replace the getter with the value
+            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
+        } else {
+            bindings.push('default', BindingTag_Value, raw);
+        }
+    }
+    esm(ns, bindings);
+    return ns;
+}
+function createNS(raw) {
+    if (typeof raw === 'function') {
+        return function(...args) {
+            return raw.apply(this, args);
+        };
+    } else {
+        return Object.create(null);
+    }
+}
+function esmImport(id) {
+    const module = getOrInstantiateModuleFromParent(id, this.m);
+    // any ES module has to have `module.namespaceObject` defined.
+    if (module.namespaceObject) return module.namespaceObject;
+    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
+    const raw = module.exports;
+    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
+}
+contextPrototype.i = esmImport;
+function asyncLoader(moduleId) {
+    const loader = this.r(moduleId);
+    return loader(esmImport.bind(this));
+}
+contextPrototype.A = asyncLoader;
+// Add a simple runtime require so that environments without one can still pass
+// `typeof require` CommonJS checks so that exports are correctly registered.
+const runtimeRequire = // @ts-ignore
+typeof require === 'function' ? require : function require1() {
+    throw new Error('Unexpected use of runtime require');
+};
+contextPrototype.t = runtimeRequire;
+function commonJsRequire(id) {
+    return getOrInstantiateModuleFromParent(id, this.m).exports;
+}
+contextPrototype.r = commonJsRequire;
+/**
+ * Remove fragments and query parameters since they are never part of the context map keys
+ *
+ * This matches how we parse patterns at resolving time.  Arguably we should only do this for
+ * strings passed to `import` but the resolve does it for `import` and `require` and so we do
+ * here as well.
+ */ function parseRequest(request) {
+    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    const hashIndex = request.indexOf('#');
+    if (hashIndex !== -1) {
+        request = request.substring(0, hashIndex);
+    }
+    const queryIndex = request.indexOf('?');
+    if (queryIndex !== -1) {
+        request = request.substring(0, queryIndex);
+    }
+    return request;
+}
+/**
+ * `require.context` and require/import expression runtime.
+ */ function moduleContext(map) {
+    function moduleContext(id) {
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].module();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    }
+    moduleContext.keys = ()=>{
+        return Object.keys(map);
+    };
+    moduleContext.resolve = (id)=>{
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].id();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    };
+    moduleContext.import = async (id)=>{
+        return await moduleContext(id);
+    };
+    return moduleContext;
+}
+contextPrototype.f = moduleContext;
+/**
+ * Returns the path of a chunk defined by its data.
+ */ function getChunkPath(chunkData) {
+    return typeof chunkData === 'string' ? chunkData : chunkData.path;
+}
+function isPromise(maybePromise) {
+    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
+}
+function isAsyncModuleExt(obj) {
+    return turbopackQueues in obj;
+}
+function createPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        reject = rej;
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
+// The CompressedModuleFactories format is
+// - 1 or more module ids
+// - a module factory function
+// So walking this is a little complex but the flat structure is also fast to
+// traverse, we can use `typeof` operators to distinguish the two cases.
+function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
+    let i = offset;
+    while(i < chunkModules.length){
+        let moduleId = chunkModules[i];
+        let end = i + 1;
+        // Find our factory function
+        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
+            end++;
+        }
+        if (end === chunkModules.length) {
+            throw new Error('malformed chunk format, expected a factory function');
+        }
+        // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already
+        // present we know all the additional ids are also present, so we don't need to check.
+        if (!moduleFactories.has(moduleId)) {
+            const moduleFactoryFn = chunkModules[end];
+            applyModuleFactoryName(moduleFactoryFn);
+            newModuleId?.(moduleId);
+            for(; i < end; i++){
+                moduleId = chunkModules[i];
+                moduleFactories.set(moduleId, moduleFactoryFn);
+            }
+        }
+        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
+    }
+}
+// everything below is adapted from webpack
+// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
+const turbopackQueues = Symbol('turbopack queues');
+const turbopackExports = Symbol('turbopack exports');
+const turbopackError = Symbol('turbopack error');
+function resolveQueue(queue) {
+    if (queue && queue.status !== 1) {
+        queue.status = 1;
+        queue.forEach((fn)=>fn.queueCount--);
+        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
+    }
+}
+function wrapDeps(deps) {
+    return deps.map((dep)=>{
+        if (dep !== null && typeof dep === 'object') {
+            if (isAsyncModuleExt(dep)) return dep;
+            if (isPromise(dep)) {
+                const queue = Object.assign([], {
+                    status: 0
+                });
+                const obj = {
+                    [turbopackExports]: {},
+                    [turbopackQueues]: (fn)=>fn(queue)
+                };
+                dep.then((res)=>{
+                    obj[turbopackExports] = res;
+                    resolveQueue(queue);
+                }, (err)=>{
+                    obj[turbopackError] = err;
+                    resolveQueue(queue);
+                });
+                return obj;
+            }
+        }
+        return {
+            [turbopackExports]: dep,
+            [turbopackQueues]: ()=>{}
+        };
+    });
+}
+function asyncModule(body, hasAwait) {
+    const module = this.m;
+    const queue = hasAwait ? Object.assign([], {
+        status: -1
+    }) : undefined;
+    const depQueues = new Set();
+    const { resolve, reject, promise: rawPromise } = createPromise();
+    const promise = Object.assign(rawPromise, {
+        [turbopackExports]: module.exports,
+        [turbopackQueues]: (fn)=>{
+            queue && fn(queue);
+            depQueues.forEach(fn);
+            promise['catch'](()=>{});
+        }
+    });
+    const attributes = {
+        get () {
+            return promise;
+        },
+        set (v) {
+            // Calling `esmExport` leads to this.
+            if (v !== promise) {
+                promise[turbopackExports] = v;
+            }
+        }
+    };
+    Object.defineProperty(module, 'exports', attributes);
+    Object.defineProperty(module, 'namespaceObject', attributes);
+    function handleAsyncDependencies(deps) {
+        const currentDeps = wrapDeps(deps);
+        const getResult = ()=>currentDeps.map((d)=>{
+                if (d[turbopackError]) throw d[turbopackError];
+                return d[turbopackExports];
+            });
+        const { promise, resolve } = createPromise();
+        const fn = Object.assign(()=>resolve(getResult), {
+            queueCount: 0
+        });
+        function fnQueue(q) {
+            if (q !== queue && !depQueues.has(q)) {
+                depQueues.add(q);
+                if (q && q.status === 0) {
+                    fn.queueCount++;
+                    q.push(fn);
+                }
+            }
+        }
+        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
+        return fn.queueCount ? promise : getResult();
+    }
+    function asyncResult(err) {
+        if (err) {
+            reject(promise[turbopackError] = err);
+        } else {
+            resolve(promise[turbopackExports]);
+        }
+        resolveQueue(queue);
+    }
+    body(handleAsyncDependencies, asyncResult);
+    if (queue && queue.status === -1) {
+        queue.status = 0;
+    }
+}
+contextPrototype.a = asyncModule;
+/**
+ * A pseudo "fake" URL object to resolve to its relative path.
+ *
+ * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
+ * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
+ * hydration mismatch.
+ *
+ * This is based on webpack's existing implementation:
+ * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
+ */ const relativeURL = function relativeURL(inputUrl) {
+    const realUrl = new URL(inputUrl, 'x:/');
+    const values = {};
+    for(const key in realUrl)values[key] = realUrl[key];
+    values.href = inputUrl;
+    values.pathname = inputUrl.replace(/[?#].*/, '');
+    values.origin = values.protocol = '';
+    values.toString = values.toJSON = (..._args)=>inputUrl;
+    for(const key in values)Object.defineProperty(this, key, {
+        enumerable: true,
+        configurable: true,
+        value: values[key]
+    });
+};
+relativeURL.prototype = URL.prototype;
+contextPrototype.U = relativeURL;
+/**
+ * Utility function to ensure all variants of an enum are handled.
+ */ function invariant(never, computeMessage) {
+    throw new Error(`Invariant: ${computeMessage(never)}`);
+}
+/**
+ * A stub function to make `require` available but non-functional in ESM.
+ */ function requireStub(_moduleId) {
+    throw new Error('dynamic usage of require is not supported');
+}
+contextPrototype.z = requireStub;
+// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
+contextPrototype.g = globalThis;
+function applyModuleFactoryName(factory) {
+    // Give the module factory a nice name to improve stack traces.
+    Object.defineProperty(factory, 'name', {
+        value: 'module evaluation'
+    });
+}
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *browser* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
+/// <reference path="../../../shared/runtime-utils.ts" />
+// Used in WebWorkers to tell the runtime about the chunk suffix
+const browserContextPrototype = Context.prototype;
+var SourceType = /*#__PURE__*/ function(SourceType) {
+    /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
+    /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */ SourceType[SourceType["Parent"] = 1] = "Parent";
+    /**
+   * The module was instantiated because it was included in a chunk's hot module
+   * update.
+   * SourceData is an array of ModuleIds or undefined.
+   */ SourceType[SourceType["Update"] = 2] = "Update";
+    return SourceType;
+}(SourceType || {});
+const moduleFactories = new Map();
+contextPrototype.M = moduleFactories;
+const availableModules = new Map();
+const availableModuleChunks = new Map();
+function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
+    let instantiationReason;
+    switch(sourceType){
+        case 0:
+            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
+            break;
+        case 1:
+            instantiationReason = `because it was required from module ${sourceData}`;
+            break;
+        case 2:
+            instantiationReason = 'because of an HMR update';
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
+}
+function loadChunk(chunkData) {
+    return loadChunkInternal(1, this.m.id, chunkData);
+}
+browserContextPrototype.l = loadChunk;
+function loadInitialChunk(chunkPath, chunkData) {
+    return loadChunkInternal(0, chunkPath, chunkData);
+}
+async function loadChunkInternal(sourceType, sourceData, chunkData) {
+    if (typeof chunkData === 'string') {
+        return loadChunkPath(sourceType, sourceData, chunkData);
+    }
+    const includedList = chunkData.included || [];
+    const modulesPromises = includedList.map((included)=>{
+        if (moduleFactories.has(included)) return true;
+        return availableModules.get(included);
+    });
+    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
+        // When all included items are already loaded or loading, we can skip loading ourselves
+        await Promise.all(modulesPromises);
+        return;
+    }
+    const includedModuleChunksList = chunkData.moduleChunks || [];
+    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
+        // TODO(alexkirsz) Do we need this check?
+        // if (moduleFactories[included]) return true;
+        return availableModuleChunks.get(included);
+    }).filter((p)=>p);
+    let promise;
+    if (moduleChunksPromises.length > 0) {
+        // Some module chunks are already loaded or loading.
+        if (moduleChunksPromises.length === includedModuleChunksList.length) {
+            // When all included module chunks are already loaded or loading, we can skip loading ourselves
+            await Promise.all(moduleChunksPromises);
+            return;
+        }
+        const moduleChunksToLoad = new Set();
+        for (const moduleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(moduleChunk)) {
+                moduleChunksToLoad.add(moduleChunk);
+            }
+        }
+        for (const moduleChunkToLoad of moduleChunksToLoad){
+            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
+            availableModuleChunks.set(moduleChunkToLoad, promise);
+            moduleChunksPromises.push(promise);
+        }
+        promise = Promise.all(moduleChunksPromises);
+    } else {
+        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
+        // Mark all included module chunks as loading if they are not already loaded or loading.
+        for (const includedModuleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(includedModuleChunk)) {
+                availableModuleChunks.set(includedModuleChunk, promise);
+            }
+        }
+    }
+    for (const included of includedList){
+        if (!availableModules.has(included)) {
+            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
+            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
+            availableModules.set(included, promise);
+        }
+    }
+    await promise;
+}
+const loadedChunk = Promise.resolve(undefined);
+const instrumentedBackendLoadChunks = new WeakMap();
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrl(chunkUrl) {
+    return loadChunkByUrlInternal(1, this.m.id, chunkUrl);
+}
+browserContextPrototype.L = loadChunkByUrl;
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
+    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
+    let entry = instrumentedBackendLoadChunks.get(thenable);
+    if (entry === undefined) {
+        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
+        entry = thenable.then(resolve).catch((cause)=>{
+            let loadReason;
+            switch(sourceType){
+                case 0:
+                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
+                    break;
+                case 1:
+                    loadReason = `from module ${sourceData}`;
+                    break;
+                case 2:
+                    loadReason = 'from an HMR update';
+                    break;
+                default:
+                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+            }
+            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
+                cause
+            } : undefined);
+            error.name = 'ChunkLoadError';
+            throw error;
+        });
+        instrumentedBackendLoadChunks.set(thenable, entry);
+    }
+    return entry;
+}
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkPath(sourceType, sourceData, chunkPath) {
+    const url = getChunkRelativeUrl(chunkPath);
+    return loadChunkByUrlInternal(sourceType, sourceData, url);
+}
+/**
+ * Returns an absolute url to an asset.
+ */ function resolvePathFromModule(moduleId) {
+    const exported = this.r(moduleId);
+    return exported?.default ?? exported;
+}
+browserContextPrototype.R = resolvePathFromModule;
+/**
+ * no-op for browser
+ * @param modulePath
+ */ function resolveAbsolutePath(modulePath) {
+    return `/ROOT/${modulePath ?? ''}`;
+}
+browserContextPrototype.P = resolveAbsolutePath;
+/**
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    const url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    const params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map((chunk)=>getChunkRelativeUrl(chunk))
+    };
+    const paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
+}
+browserContextPrototype.b = getWorkerURL;
+/**
+ * Instantiates a runtime module.
+ */ function instantiateRuntimeModule(moduleId, chunkPath) {
+    return instantiateModule(moduleId, 0, chunkPath);
+}
+/**
+ * Returns the URL relative to the origin where a chunk can be fetched from.
+ */ function getChunkRelativeUrl(chunkPath) {
+    return `${CHUNK_BASE_PATH}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${CHUNK_SUFFIX}`;
+}
+function getPathFromScript(chunkScript) {
+    if (typeof chunkScript === 'string') {
+        return chunkScript;
+    }
+    const chunkUrl = typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' ? TURBOPACK_NEXT_CHUNK_URLS.pop() : chunkScript.getAttribute('src');
+    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
+    const path = src.startsWith(CHUNK_BASE_PATH) ? src.slice(CHUNK_BASE_PATH.length) : src;
+    return path;
+}
+const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.
+ */ function isJs(chunkUrlOrPath) {
+    return regexJsUrl.test(chunkUrlOrPath);
+}
+const regexCssUrl = /\.css(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.
+ */ function isCss(chunkUrl) {
+    return regexCssUrl.test(chunkUrl);
+}
+function loadWebAssembly(chunkPath, edgeModule, importsObj) {
+    return BACKEND.loadWebAssembly(1, this.m.id, chunkPath, edgeModule, importsObj);
+}
+contextPrototype.w = loadWebAssembly;
+function loadWebAssemblyModule(chunkPath, edgeModule) {
+    return BACKEND.loadWebAssemblyModule(1, this.m.id, chunkPath, edgeModule);
+}
+contextPrototype.u = loadWebAssemblyModule;
+/// <reference path="./dev-globals.d.ts" />
+/// <reference path="./dev-protocol.d.ts" />
+/// <reference path="./dev-extensions.ts" />
+const devContextPrototype = Context.prototype;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *development* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ const devModuleCache = Object.create(null);
+devContextPrototype.c = devModuleCache;
+class UpdateApplyError extends Error {
+    name = 'UpdateApplyError';
+    dependencyChain;
+    constructor(message, dependencyChain){
+        super(message);
+        this.dependencyChain = dependencyChain;
+    }
+}
+/**
+ * Module IDs that are instantiated as part of the runtime of a chunk.
+ */ const runtimeModules = new Set();
+/**
+ * Map from module ID to the chunks that contain this module.
+ *
+ * In HMR, we need to keep track of which modules are contained in which so
+ * chunks. This is so we don't eagerly dispose of a module when it is removed
+ * from chunk A, but still exists in chunk B.
+ */ const moduleChunksMap = new Map();
+/**
+ * Map from a chunk path to all modules it contains.
+ */ const chunkModulesMap = new Map();
+/**
+ * Chunk lists that contain a runtime. When these chunk lists receive an update
+ * that can't be reconciled with the current state of the page, we need to
+ * reload the runtime entirely.
+ */ const runtimeChunkLists = new Set();
+/**
+ * Map from a chunk list to the chunk paths it contains.
+ */ const chunkListChunksMap = new Map();
+/**
+ * Map from a chunk path to the chunk lists it belongs to.
+ */ const chunkChunkListsMap = new Map();
+/**
+ * Maps module IDs to persisted data between executions of their hot module
+ * implementation (`hot.data`).
+ */ const moduleHotData = new Map();
+/**
+ * Maps module instances to their hot module state.
+ */ const moduleHotState = new Map();
+/**
+ * Modules that call `module.hot.invalidate()` (while being updated).
+ */ const queuedInvalidatedModules = new Set();
+/**
+ * Gets or instantiates a runtime module.
+ */ // @ts-ignore
+function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
+    const module = devModuleCache[moduleId];
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        return module;
+    }
+    // @ts-ignore
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */ // @ts-ignore Defined in `runtime-utils.ts`
+const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
+    if (!sourceModule.hot.active) {
+        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
+    }
+    const module = devModuleCache[id];
+    if (sourceModule.children.indexOf(id) === -1) {
+        sourceModule.children.push(id);
+    }
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        if (module.parents.indexOf(sourceModule.id) === -1) {
+            module.parents.push(sourceModule.id);
+        }
+        return module;
+    }
+    return instantiateModule(id, SourceType.Parent, sourceModule.id);
+};
+function DevContext(module, exports, refresh) {
+    Context.call(this, module, exports);
+    this.k = refresh;
+}
+DevContext.prototype = Context.prototype;
+function instantiateModule(moduleId, sourceType, sourceData) {
+    // We are in development, this is always a string.
+    let id = moduleId;
+    const moduleFactory = moduleFactories.get(id);
+    if (typeof moduleFactory !== 'function') {
+        // This can happen if modules incorrectly handle HMR disposes/updates,
+        // e.g. when they keep a `setTimeout` around which still executes old code
+        // and contains e.g. a `require("something")` call.
+        throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData) + ' It might have been deleted in an HMR update.');
+    }
+    const hotData = moduleHotData.get(id);
+    const { hot, hotState } = createModuleHot(id, hotData);
+    let parents;
+    switch(sourceType){
+        case SourceType.Runtime:
+            runtimeModules.add(id);
+            parents = [];
+            break;
+        case SourceType.Parent:
+            // No need to add this module as a child of the parent module here, this
+            // has already been taken care of in `getOrInstantiateModuleFromParent`.
+            parents = [
+                sourceData
+            ];
+            break;
+        case SourceType.Update:
+            parents = sourceData || [];
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    const module = createModuleObject(id);
+    const exports = module.exports;
+    module.parents = parents;
+    module.children = [];
+    module.hot = hot;
+    devModuleCache[id] = module;
+    moduleHotState.set(module, hotState);
+    // NOTE(alexkirsz) This can fail when the module encounters a runtime error.
+    try {
+        runModuleExecutionHooks(module, (refresh)=>{
+            const context = new DevContext(module, exports, refresh);
+            moduleFactory(context, module, exports);
+        });
+    } catch (error) {
+        module.error = error;
+        throw error;
+    }
+    if (module.namespaceObject && module.exports !== module.namespaceObject) {
+        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+        interopEsm(module.exports, module.namespaceObject);
+    }
+    return module;
+}
+const DUMMY_REFRESH_CONTEXT = {
+    register: (_type, _id)=>{},
+    signature: ()=>(_type)=>{},
+    registerExports: (_module, _helpers)=>{}
+};
+/**
+ * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
+ * Next.js' React Refresh runtime hooks into to add module context to the
+ * refresh registry.
+ */ function runModuleExecutionHooks(module, executeModule) {
+    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
+        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
+        try {
+            executeModule({
+                register: globalThis.$RefreshReg$,
+                signature: globalThis.$RefreshSig$,
+                registerExports: registerExportsAndSetupBoundaryForReactRefresh
+            });
+        } finally{
+            // Always cleanup the intercept, even if module execution failed.
+            cleanupReactRefreshIntercept();
+        }
+    } else {
+        // If the react refresh hooks are not installed we need to bind dummy functions.
+        // This is expected when running in a Web Worker.  It is also common in some of
+        // our test environments.
+        executeModule(DUMMY_REFRESH_CONTEXT);
+    }
+}
+/**
+ * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+ */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
+    const currentExports = module.exports;
+    const prevExports = module.hot.data.prevExports ?? null;
+    helpers.registerExportsForReactRefresh(currentExports, module.id);
+    // A module can be accepted automatically based on its exports, e.g. when
+    // it is a Refresh Boundary.
+    if (helpers.isReactRefreshBoundary(currentExports)) {
+        // Save the previous exports on update, so we can compare the boundary
+        // signatures.
+        module.hot.dispose((data)=>{
+            data.prevExports = currentExports;
+        });
+        // Unconditionally accept an update to this module, we'll check if it's
+        // still a Refresh Boundary later.
+        module.hot.accept();
+        // This field is set when the previous version of this module was a
+        // Refresh Boundary, letting us know we need to check for invalidation or
+        // enqueue an update.
+        if (prevExports !== null) {
+            // A boundary can become ineligible if its exports are incompatible
+            // with the previous exports.
+            //
+            // For example, if you add/remove/change exports, we'll want to
+            // re-execute the importing modules, and force those components to
+            // re-render. Similarly, if you convert a class component to a
+            // function, we want to invalidate the boundary.
+            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
+                module.hot.invalidate();
+            } else {
+                helpers.scheduleUpdate();
+            }
+        }
+    } else {
+        // Since we just executed the code for the module, it's possible that the
+        // new exports made it ineligible for being a boundary.
+        // We only care about the case when we were _previously_ a boundary,
+        // because we already accepted this update (accidental side effect).
+        const isNoLongerABoundary = prevExports !== null;
+        if (isNoLongerABoundary) {
+            module.hot.invalidate();
+        }
+    }
+}
+function formatDependencyChain(dependencyChain) {
+    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
+}
+function computeOutdatedModules(added, modified) {
+    const newModuleFactories = new Map();
+    for (const [moduleId, entry] of added){
+        if (entry != null) {
+            newModuleFactories.set(moduleId, _eval(entry));
+        }
+    }
+    const outdatedModules = computedInvalidatedModules(modified.keys());
+    for (const [moduleId, entry] of modified){
+        newModuleFactories.set(moduleId, _eval(entry));
+    }
+    return {
+        outdatedModules,
+        newModuleFactories
+    };
+}
+function computedInvalidatedModules(invalidated) {
+    const outdatedModules = new Set();
+    for (const moduleId of invalidated){
+        const effect = getAffectedModuleEffects(moduleId);
+        switch(effect.type){
+            case 'unaccepted':
+                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'self-declined':
+                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'accepted':
+                for (const outdatedModuleId of effect.outdatedModules){
+                    outdatedModules.add(outdatedModuleId);
+                }
+                break;
+            // TODO(alexkirsz) Dependencies: handle dependencies effects.
+            default:
+                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
+        }
+    }
+    return outdatedModules;
+}
+function computeOutdatedSelfAcceptedModules(outdatedModules) {
+    const outdatedSelfAcceptedModules = [];
+    for (const moduleId of outdatedModules){
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (module && hotState.selfAccepted && !hotState.selfInvalidated) {
+            outdatedSelfAcceptedModules.push({
+                moduleId,
+                errorHandler: hotState.selfAccepted
+            });
+        }
+    }
+    return outdatedSelfAcceptedModules;
+}
+/**
+ * Adds, deletes, and moves modules between chunks. This must happen before the
+ * dispose phase as it needs to know which modules were removed from all chunks,
+ * which we can only compute *after* taking care of added and moved modules.
+ */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
+    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
+        for (const moduleId of addedModuleIds){
+            addModuleToChunk(moduleId, chunkPath);
+        }
+    }
+    const disposedModules = new Set();
+    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
+        for (const moduleId of addedModuleIds){
+            if (removeModuleFromChunk(moduleId, chunkPath)) {
+                disposedModules.add(moduleId);
+            }
+        }
+    }
+    return {
+        disposedModules
+    };
+}
+function disposePhase(outdatedModules, disposedModules) {
+    for (const moduleId of outdatedModules){
+        disposeModule(moduleId, 'replace');
+    }
+    for (const moduleId of disposedModules){
+        disposeModule(moduleId, 'clear');
+    }
+    // Removing modules from the module cache is a separate step.
+    // We also want to keep track of previous parents of the outdated modules.
+    const outdatedModuleParents = new Map();
+    for (const moduleId of outdatedModules){
+        const oldModule = devModuleCache[moduleId];
+        outdatedModuleParents.set(moduleId, oldModule?.parents);
+        delete devModuleCache[moduleId];
+    }
+    // TODO(alexkirsz) Dependencies: remove outdated dependency from module
+    // children.
+    return {
+        outdatedModuleParents
+    };
+}
+/**
+ * Disposes of an instance of a module.
+ *
+ * Returns the persistent hot data that should be kept for the next module
+ * instance.
+ *
+ * NOTE: mode = "replace" will not remove modules from the devModuleCache
+ * This must be done in a separate step afterwards.
+ * This is important because all modules need to be disposed to update the
+ * parent/child relationships before they are actually removed from the devModuleCache.
+ * If this was done in this method, the following disposeModule calls won't find
+ * the module from the module id in the cache.
+ */ function disposeModule(moduleId, mode) {
+    const module = devModuleCache[moduleId];
+    if (!module) {
+        return;
+    }
+    const hotState = moduleHotState.get(module);
+    const data = {};
+    // Run the `hot.dispose` handler, if any, passing in the persistent
+    // `hot.data` object.
+    for (const disposeHandler of hotState.disposeHandlers){
+        disposeHandler(data);
+    }
+    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
+    // module is still importing other modules.
+    module.hot.active = false;
+    moduleHotState.delete(module);
+    // TODO(alexkirsz) Dependencies: delete the module from outdated deps.
+    // Remove the disposed module from its children's parent list.
+    // It will be added back once the module re-instantiates and imports its
+    // children again.
+    for (const childId of module.children){
+        const child = devModuleCache[childId];
+        if (!child) {
+            continue;
+        }
+        const idx = child.parents.indexOf(module.id);
+        if (idx >= 0) {
+            child.parents.splice(idx, 1);
+        }
+    }
+    switch(mode){
+        case 'clear':
+            delete devModuleCache[module.id];
+            moduleHotData.delete(module.id);
+            break;
+        case 'replace':
+            moduleHotData.set(module.id, data);
+            break;
+        default:
+            invariant(mode, (mode)=>`invalid mode: ${mode}`);
+    }
+}
+function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError) {
+    // Update module factories.
+    for (const [moduleId, factory] of newModuleFactories.entries()){
+        applyModuleFactoryName(factory);
+        moduleFactories.set(moduleId, factory);
+    }
+    // TODO(alexkirsz) Run new runtime entries here.
+    // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.
+    // Re-instantiate all outdated self-accepted modules.
+    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
+        try {
+            instantiateModule(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
+        } catch (err) {
+            if (typeof errorHandler === 'function') {
+                try {
+                    errorHandler(err, {
+                        moduleId,
+                        module: devModuleCache[moduleId]
+                    });
+                } catch (err2) {
+                    reportError(err2);
+                    reportError(err);
+                }
+            } else {
+                reportError(err);
+            }
+        }
+    }
+}
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+    }
+}
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+        }
+    }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+            }
+        }
+    }
+}
+function applyEcmascriptMergedUpdate(update) {
+    const { entries = {}, chunks = {} } = update;
+    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks);
+    const { outdatedModules, newModuleFactories } = computeOutdatedModules(added, modified);
+    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
+    applyInternal(outdatedModules, disposedModules, newModuleFactories);
+}
+function applyInvalidatedModules(outdatedModules) {
+    if (queuedInvalidatedModules.size > 0) {
+        computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId)=>{
+            outdatedModules.add(moduleId);
+        });
+        queuedInvalidatedModules.clear();
+    }
+    return outdatedModules;
+}
+function applyInternal(outdatedModules, disposedModules, newModuleFactories) {
+    outdatedModules = applyInvalidatedModules(outdatedModules);
+    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
+    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules);
+    // we want to continue on error and only throw the error after we tried applying all updates
+    let error;
+    function reportError(err) {
+        if (!error) error = err;
+    }
+    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError);
+    if (error) {
+        throw error;
+    }
+    if (queuedInvalidatedModules.size > 0) {
+        applyInternal(new Set(), [], new Map());
+    }
+}
+function computeChangedModules(entries, updates) {
+    const chunksAdded = new Map();
+    const chunksDeleted = new Map();
+    const added = new Map();
+    const modified = new Map();
+    const deleted = new Set();
+    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
+        switch(mergedChunkUpdate.type){
+            case 'added':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.modules);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    break;
+                }
+            case 'deleted':
+                {
+                    // We could also use `mergedChunkUpdate.modules` here.
+                    const updateDeleted = new Set(chunkModulesMap.get(chunkPath));
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            case 'partial':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.added);
+                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            default:
+                invariant(mergedChunkUpdate, (mergedChunkUpdate)=>`Unknown merged chunk update type: ${mergedChunkUpdate.type}`);
+        }
+    }
+    // If a module was added from one chunk and deleted from another in the same update,
+    // consider it to be modified, as it means the module was moved from one chunk to another
+    // AND has new code in a single update.
+    for (const moduleId of added.keys()){
+        if (deleted.has(moduleId)) {
+            added.delete(moduleId);
+            deleted.delete(moduleId);
+        }
+    }
+    for (const [moduleId, entry] of Object.entries(entries)){
+        // Modules that haven't been added to any chunk but have new code are considered
+        // to be modified.
+        // This needs to be under the previous loop, as we need it to get rid of modules
+        // that were added and deleted in the same update.
+        if (!added.has(moduleId)) {
+            modified.set(moduleId, entry);
+        }
+    }
+    return {
+        added,
+        deleted,
+        modified,
+        chunksAdded,
+        chunksDeleted
+    };
+}
+function getAffectedModuleEffects(moduleId) {
+    const outdatedModules = new Set();
+    const queue = [
+        {
+            moduleId,
+            dependencyChain: []
+        }
+    ];
+    let nextItem;
+    while(nextItem = queue.shift()){
+        const { moduleId, dependencyChain } = nextItem;
+        if (moduleId != null) {
+            if (outdatedModules.has(moduleId)) {
+                continue;
+            }
+            outdatedModules.add(moduleId);
+        }
+        // We've arrived at the runtime of the chunk, which means that nothing
+        // else above can accept this update.
+        if (moduleId === undefined) {
+            return {
+                type: 'unaccepted',
+                dependencyChain
+            };
+        }
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (// The module is not in the cache. Since this is a "modified" update,
+        // it means that the module was never instantiated before.
+        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
+            continue;
+        }
+        if (hotState.selfDeclined) {
+            return {
+                type: 'self-declined',
+                dependencyChain,
+                moduleId
+            };
+        }
+        if (runtimeModules.has(moduleId)) {
+            queue.push({
+                moduleId: undefined,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+            continue;
+        }
+        for (const parentId of module.parents){
+            const parent = devModuleCache[parentId];
+            if (!parent) {
+                continue;
+            }
+            // TODO(alexkirsz) Dependencies: check accepted and declined
+            // dependencies here.
+            queue.push({
+                moduleId: parentId,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+        }
+    }
+    return {
+        type: 'accepted',
+        moduleId,
+        outdatedModules
+    };
+}
+function handleApply(chunkListPath, update) {
+    switch(update.type){
+        case 'partial':
+            {
+                // This indicates that the update is can be applied to the current state of the application.
+                applyUpdate(update.instruction);
+                break;
+            }
+        case 'restart':
+            {
+                // This indicates that there is no way to apply the update to the
+                // current state of the application, and that the application must be
+                // restarted.
+                DEV_BACKEND.restart();
+                break;
+            }
+        case 'notFound':
+            {
+                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
+                // or the page itself was deleted.
+                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
+                // If it is a runtime chunk list, we restart the application.
+                if (runtimeChunkLists.has(chunkListPath)) {
+                    DEV_BACKEND.restart();
+                } else {
+                    disposeChunkList(chunkListPath);
+                }
+                break;
+            }
+        default:
+            throw new Error(`Unknown update type: ${update.type}`);
+    }
+}
+function createModuleHot(moduleId, hotData) {
+    const hotState = {
+        selfAccepted: false,
+        selfDeclined: false,
+        selfInvalidated: false,
+        disposeHandlers: []
+    };
+    const hot = {
+        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
+        // decide whether to warn whenever an HMR-disposed module required other
+        // modules. We might want to remove it.
+        active: true,
+        data: hotData ?? {},
+        // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.
+        accept: (modules, _callback, _errorHandler)=>{
+            if (modules === undefined) {
+                hotState.selfAccepted = true;
+            } else if (typeof modules === 'function') {
+                hotState.selfAccepted = modules;
+            } else {
+                throw new Error('unsupported `accept` signature');
+            }
+        },
+        decline: (dep)=>{
+            if (dep === undefined) {
+                hotState.selfDeclined = true;
+            } else {
+                throw new Error('unsupported `decline` signature');
+            }
+        },
+        dispose: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        addDisposeHandler: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        removeDisposeHandler: (callback)=>{
+            const idx = hotState.disposeHandlers.indexOf(callback);
+            if (idx >= 0) {
+                hotState.disposeHandlers.splice(idx, 1);
+            }
+        },
+        invalidate: ()=>{
+            hotState.selfInvalidated = true;
+            queuedInvalidatedModules.add(moduleId);
+        },
+        // NOTE(alexkirsz) This is part of the management API, which we don't
+        // implement, but the Next.js React Refresh runtime uses this to decide
+        // whether to schedule an update.
+        status: ()=>'idle',
+        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
+        addStatusHandler: (_handler)=>{},
+        removeStatusHandler: (_handler)=>{},
+        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
+        // want the webpack code paths to ever update (the turbopack paths handle
+        // this already).
+        check: ()=>Promise.resolve(null)
+    };
+    return {
+        hot,
+        hotState
+    };
+}
+/**
+ * Removes a module from a chunk.
+ * Returns `true` if there are no remaining chunks including this module.
+ */ function removeModuleFromChunk(moduleId, chunkPath) {
+    const moduleChunks = moduleChunksMap.get(moduleId);
+    moduleChunks.delete(chunkPath);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    chunkModules.delete(moduleId);
+    const noRemainingModules = chunkModules.size === 0;
+    if (noRemainingModules) {
+        chunkModulesMap.delete(chunkPath);
+    }
+    const noRemainingChunks = moduleChunks.size === 0;
+    if (noRemainingChunks) {
+        moduleChunksMap.delete(moduleId);
+    }
+    return noRemainingChunks;
+}
+/**
+ * Disposes of a chunk list and its corresponding exclusive chunks.
+ */ function disposeChunkList(chunkListPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (chunkPaths == null) {
+        return false;
+    }
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
+            disposeChunk(chunkPath);
+        }
+    }
+    // We must also dispose of the chunk list's chunk itself to ensure it may
+    // be reloaded properly in the future.
+    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
+    DEV_BACKEND.unloadChunk?.(chunkListUrl);
+    return true;
+}
+/**
+ * Disposes of a chunk and its corresponding exclusive modules.
+ *
+ * @returns Whether the chunk was disposed of.
+ */ function disposeChunk(chunkPath) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    // This should happen whether the chunk has any modules in it or not.
+    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
+    DEV_BACKEND.unloadChunk?.(chunkUrl);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    if (chunkModules == null) {
+        return false;
+    }
+    chunkModules.delete(chunkPath);
+    for (const moduleId of chunkModules){
+        const moduleChunks = moduleChunksMap.get(moduleId);
+        moduleChunks.delete(chunkPath);
+        const noRemainingChunks = moduleChunks.size === 0;
+        if (noRemainingChunks) {
+            moduleChunksMap.delete(moduleId);
+            disposeModule(moduleId, 'clear');
+            availableModules.delete(moduleId);
+        }
+    }
+    return true;
+}
+/**
+ * Adds a module to a chunk.
+ */ function addModuleToChunk(moduleId, chunkPath) {
+    let moduleChunks = moduleChunksMap.get(moduleId);
+    if (!moduleChunks) {
+        moduleChunks = new Set([
+            chunkPath
+        ]);
+        moduleChunksMap.set(moduleId, moduleChunks);
+    } else {
+        moduleChunks.add(chunkPath);
+    }
+    let chunkModules = chunkModulesMap.get(chunkPath);
+    if (!chunkModules) {
+        chunkModules = new Set([
+            moduleId
+        ]);
+        chunkModulesMap.set(chunkPath, chunkModules);
+    } else {
+        chunkModules.add(moduleId);
+    }
+}
+/**
+ * Marks a chunk list as a runtime chunk list. There can be more than one
+ * runtime chunk list. For instance, integration tests can have multiple chunk
+ * groups loaded at runtime, each with its own chunk list.
+ */ function markChunkListAsRuntime(chunkListPath) {
+    runtimeChunkLists.add(chunkListPath);
+}
+function registerChunk(registration) {
+    const chunkPath = getPathFromScript(registration[0]);
+    let runtimeParams;
+    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
+    if (registration.length === 2) {
+        runtimeParams = registration[1];
+    } else {
+        runtimeParams = undefined;
+        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
+    }
+    return BACKEND.registerChunk(chunkPath, runtimeParams);
+}
+/**
+ * Subscribes to chunk list updates from the update server and applies them.
+ */ function registerChunkList(chunkList) {
+    const chunkListScript = chunkList.script;
+    const chunkListPath = getPathFromScript(chunkListScript);
+    // The "chunk" is also registered to finish the loading in the backend
+    BACKEND.registerChunk(chunkListPath);
+    globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath)
+    ]);
+    // Adding chunks to chunk lists and vice versa.
+    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
+    if (chunkList.source === 'entry') {
+        markChunkListAsRuntime(chunkListPath);
+    }
+}
+globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
+/**
+ * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
+ *
+ * It will be appended to the base runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
+/// <reference path="../../../shared/runtime-types.d.ts" />
+function getChunkSuffixFromScriptSrc() {
+    // TURBOPACK_CHUNK_SUFFIX is set in web workers
+    return (self.TURBOPACK_CHUNK_SUFFIX ?? document?.currentScript?.getAttribute?.('src')?.replace(/^(.*(?=\?)|^.*$)/, '')) || '';
+}
+let BACKEND;
+/**
+ * Maps chunk paths to the corresponding resolver.
+ */ const chunkResolvers = new Map();
+(()=>{
+    BACKEND = {
+        async registerChunk (chunkPath, params) {
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            const resolver = getOrCreateResolver(chunkUrl);
+            resolver.resolve();
+            if (params == null) {
+                return;
+            }
+            for (const otherChunkData of params.otherChunks){
+                const otherChunkPath = getChunkPath(otherChunkData);
+                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
+                // Chunk might have started loading, so we want to avoid triggering another load.
+                getOrCreateResolver(otherChunkUrl);
+            }
+            // This waits for chunks to be loaded, but also marks included items as available.
+            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
+            if (params.runtimeModuleIds.length > 0) {
+                for (const moduleId of params.runtimeModuleIds){
+                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
+                }
+            }
+        },
+        /**
+     * Loads the given chunk, and returns a promise that resolves once the chunk
+     * has been loaded.
+     */ loadChunkCached (sourceType, chunkUrl) {
+            return doLoadChunk(sourceType, chunkUrl);
+        },
+        async loadWebAssembly (_sourceType, _sourceData, wasmChunkPath, _edgeModule, importsObj) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            const { instance } = await WebAssembly.instantiateStreaming(req, importsObj);
+            return instance.exports;
+        },
+        async loadWebAssemblyModule (_sourceType, _sourceData, wasmChunkPath, _edgeModule) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            return await WebAssembly.compileStreaming(req);
+        }
+    };
+    function getOrCreateResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        return resolver;
+    }
+    /**
+   * Loads the given chunk, and returns a promise that resolves once the chunk
+   * has been loaded.
+   */ function doLoadChunk(sourceType, chunkUrl) {
+        const resolver = getOrCreateResolver(chunkUrl);
+        if (resolver.loadingStarted) {
+            return resolver.promise;
+        }
+        if (sourceType === SourceType.Runtime) {
+            // We don't need to load chunks references from runtime code, as they're already
+            // present in the DOM.
+            resolver.loadingStarted = true;
+            if (isCss(chunkUrl)) {
+                // CSS chunks do not register themselves, and as such must be marked as
+                // loaded instantly.
+                resolver.resolve();
+            }
+            // We need to wait for JS chunks to register themselves within `registerChunk`
+            // before we can start instantiating runtime modules, hence the absence of
+            // `resolver.resolve()` in this branch.
+            return resolver.promise;
+        }
+        if (typeof importScripts === 'function') {
+            // We're in a web worker
+            if (isCss(chunkUrl)) {
+            // ignore
+            } else if (isJs(chunkUrl)) {
+                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
+                importScripts(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
+            }
+        } else {
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length > 0) {
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolver.resolve();
+                } else {
+                    const link = document.createElement('link');
+                    link.rel = 'stylesheet';
+                    link.href = chunkUrl;
+                    link.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    link.onload = ()=>{
+                        // CSS chunks do not register themselves, and as such must be marked as
+                        // loaded instantly.
+                        resolver.resolve();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(link);
+                }
+            } else if (isJs(chunkUrl)) {
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    // There is this edge where the script already failed loading, but we
+                    // can't detect that. The Promise will never resolve in this case.
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            resolver.reject();
+                        });
+                    }
+                } else {
+                    const script = document.createElement('script');
+                    script.src = chunkUrl;
+                    // We'll only mark the chunk as loaded once the script has been executed,
+                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
+                    // this branch.
+                    script.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(script);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        }
+        resolver.loadingStarted = true;
+        return resolver.promise;
+    }
+    function fetchWebAssembly(wasmChunkPath) {
+        return fetch(getChunkRelativeUrl(wasmChunkPath));
+    }
+})();
+/**
+ * This file contains the runtime code specific to the Turbopack development
+ * ECMAScript DOM runtime.
+ *
+ * It will be appended to the base development runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
+/// <reference path="../base/dev-base.ts" />
+/// <reference path="./runtime-backend-dom.ts" />
+/// <reference path="../../../shared/require-type.d.ts" />
+let DEV_BACKEND;
+(()=>{
+    DEV_BACKEND = {
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${chunkUrl}"],link[href^="${chunkUrl}?"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
+                }
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        },
+        reloadChunk (chunkUrl) {
+            return new Promise((resolve, reject)=>{
+                if (!isCss(chunkUrl)) {
+                    reject(new Error('The DOM backend can only reload CSS chunks'));
+                    return;
+                }
+                const decodedChunkUrl = decodeURI(chunkUrl);
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length === 0) {
+                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
+                    return;
+                }
+                const link = document.createElement('link');
+                link.rel = 'stylesheet';
+                if (navigator.userAgent.includes('Firefox')) {
+                    // Firefox won't reload CSS files that were previously loaded on the current page,
+                    // we need to add a query param to make sure CSS is actually reloaded from the server.
+                    //
+                    // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
+                    //
+                    // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag
+                    // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726
+                    link.href = `${chunkUrl}?ts=${Date.now()}`;
+                } else {
+                    link.href = chunkUrl;
+                }
+                link.onerror = ()=>{
+                    reject();
+                };
+                link.onload = ()=>{
+                    // First load the new CSS, then remove the old ones. This prevents visible
+                    // flickering that would happen in-between removing the previous CSS and
+                    // loading the new one.
+                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolve();
+                };
+                // Make sure to insert the new CSS right after the previous one, so that
+                // its precedence is higher.
+                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
+            });
+        },
+        restart: ()=>self.location.reload()
+    };
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
+    }
+})();
+function _eval({ code, url, map }) {
+    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX)}`;
+    if (map) {
+        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
+        // See https://stackoverflow.com/a/26603875
+        unescape(encodeURIComponent(map)))}`;
+    }
+    // eslint-disable-next-line no-eval
+    return eval(code);
+}
+const chunksToRegister = globalThis.TURBOPACK;
+globalThis.TURBOPACK = { push: registerChunk };
+chunksToRegister.forEach(registerChunk);
+const chunkListsToRegister = globalThis.TURBOPACK_CHUNK_LISTS || [];
+globalThis.TURBOPACK_CHUNK_LISTS = { push: registerChunkList };
+chunkListsToRegister.forEach(registerChunkList);
+})();
+
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_index_818b7886.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js
new file mode 100644
index 00000000000000..af7ede5d0069fb
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js
@@ -0,0 +1,1869 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([
+    "output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js",
+    {"otherChunks":["output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js [test] (ecmascript)"]}
+]);
+(() => {
+if (!Array.isArray(globalThis.TURBOPACK)) {
+    return;
+}
+
+const CHUNK_BASE_PATH = "";
+const RELATIVE_ROOT_PATH = "../../../../../../..";
+const RUNTIME_PUBLIC_PATH = "";
+const CHUNK_SUFFIX = "";
+/**
+ * This file contains runtime types and functions that are shared between all
+ * TurboPack ECMAScript runtimes.
+ *
+ * It will be prepended to the runtime code of each runtime.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="./runtime-types.d.ts" />
+const REEXPORTED_OBJECTS = new WeakMap();
+/**
+ * Constructs the `__turbopack_context__` object for a module.
+ */ function Context(module, exports) {
+    this.m = module;
+    // We need to store this here instead of accessing it from the module object to:
+    // 1. Make it available to factories directly, since we rewrite `this` to
+    //    `__turbopack_context__.e` in CJS modules.
+    // 2. Support async modules which rewrite `module.exports` to a promise, so we
+    //    can still access the original exports object from functions like
+    //    `esmExport`
+    // Ideally we could find a new approach for async modules and drop this property altogether.
+    this.e = exports;
+}
+const contextPrototype = Context.prototype;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag;
+function defineProp(obj, name, options) {
+    if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options);
+}
+function getOverwrittenModule(moduleCache, id) {
+    let module = moduleCache[id];
+    if (!module) {
+        // This is invoked when a module is merged into another module, thus it wasn't invoked via
+        // instantiateModule and the cache entry wasn't created yet.
+        module = createModuleObject(id);
+        moduleCache[id] = module;
+    }
+    return module;
+}
+/**
+ * Creates the module object. Only done here to ensure all module objects have the same shape.
+ */ function createModuleObject(id) {
+    return {
+        exports: {},
+        error: undefined,
+        id,
+        namespaceObject: undefined
+    };
+}
+const BindingTag_Value = 0;
+/**
+ * Adds the getters to the exports object.
+ */ function esm(exports, bindings) {
+    defineProp(exports, '__esModule', {
+        value: true
+    });
+    if (toStringTag) defineProp(exports, toStringTag, {
+        value: 'Module'
+    });
+    let i = 0;
+    while(i < bindings.length){
+        const propName = bindings[i++];
+        const tagOrFunction = bindings[i++];
+        if (typeof tagOrFunction === 'number') {
+            if (tagOrFunction === BindingTag_Value) {
+                defineProp(exports, propName, {
+                    value: bindings[i++],
+                    enumerable: true,
+                    writable: false
+                });
+            } else {
+                throw new Error(`unexpected tag: ${tagOrFunction}`);
+            }
+        } else {
+            const getterFn = tagOrFunction;
+            if (typeof bindings[i] === 'function') {
+                const setterFn = bindings[i++];
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    set: setterFn,
+                    enumerable: true
+                });
+            } else {
+                defineProp(exports, propName, {
+                    get: getterFn,
+                    enumerable: true
+                });
+            }
+        }
+    }
+    Object.seal(exports);
+}
+/**
+ * Makes the module an ESM with exports
+ */ function esmExport(bindings, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    module.namespaceObject = exports;
+    esm(exports, bindings);
+}
+contextPrototype.s = esmExport;
+function ensureDynamicExports(module, exports) {
+    let reexportedObjects = REEXPORTED_OBJECTS.get(module);
+    if (!reexportedObjects) {
+        REEXPORTED_OBJECTS.set(module, reexportedObjects = []);
+        module.exports = module.namespaceObject = new Proxy(exports, {
+            get (target, prop) {
+                if (hasOwnProperty.call(target, prop) || prop === 'default' || prop === '__esModule') {
+                    return Reflect.get(target, prop);
+                }
+                for (const obj of reexportedObjects){
+                    const value = Reflect.get(obj, prop);
+                    if (value !== undefined) return value;
+                }
+                return undefined;
+            },
+            ownKeys (target) {
+                const keys = Reflect.ownKeys(target);
+                for (const obj of reexportedObjects){
+                    for (const key of Reflect.ownKeys(obj)){
+                        if (key !== 'default' && !keys.includes(key)) keys.push(key);
+                    }
+                }
+                return keys;
+            }
+        });
+    }
+    return reexportedObjects;
+}
+/**
+ * Dynamically exports properties from an object
+ */ function dynamicExport(object, id) {
+    let module;
+    let exports;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+        exports = module.exports;
+    } else {
+        module = this.m;
+        exports = this.e;
+    }
+    const reexportedObjects = ensureDynamicExports(module, exports);
+    if (typeof object === 'object' && object !== null) {
+        reexportedObjects.push(object);
+    }
+}
+contextPrototype.j = dynamicExport;
+function exportValue(value, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = value;
+}
+contextPrototype.v = exportValue;
+function exportNamespace(namespace, id) {
+    let module;
+    if (id != null) {
+        module = getOverwrittenModule(this.c, id);
+    } else {
+        module = this.m;
+    }
+    module.exports = module.namespaceObject = namespace;
+}
+contextPrototype.n = exportNamespace;
+function createGetter(obj, key) {
+    return ()=>obj[key];
+}
+/**
+ * @returns prototype of the object
+ */ const getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+/** Prototypes that are not expanded for exports */ const LEAF_PROTOTYPES = [
+    null,
+    getProto({}),
+    getProto([]),
+    getProto(getProto)
+];
+/**
+ * @param raw
+ * @param ns
+ * @param allowExportDefault
+ *   * `false`: will have the raw module as default export
+ *   * `true`: will have the default property as default export
+ */ function interopEsm(raw, ns, allowExportDefault) {
+    const bindings = [];
+    let defaultLocation = -1;
+    for(let current = raw; (typeof current === 'object' || typeof current === 'function') && !LEAF_PROTOTYPES.includes(current); current = getProto(current)){
+        for (const key of Object.getOwnPropertyNames(current)){
+            bindings.push(key, createGetter(raw, key));
+            if (defaultLocation === -1 && key === 'default') {
+                defaultLocation = bindings.length - 1;
+            }
+        }
+    }
+    // this is not really correct
+    // we should set the `default` getter if the imported module is a `.cjs file`
+    if (!(allowExportDefault && defaultLocation >= 0)) {
+        // Replace the binding with one for the namespace itself in order to preserve iteration order.
+        if (defaultLocation >= 0) {
+            // Replace the getter with the value
+            bindings.splice(defaultLocation, 1, BindingTag_Value, raw);
+        } else {
+            bindings.push('default', BindingTag_Value, raw);
+        }
+    }
+    esm(ns, bindings);
+    return ns;
+}
+function createNS(raw) {
+    if (typeof raw === 'function') {
+        return function(...args) {
+            return raw.apply(this, args);
+        };
+    } else {
+        return Object.create(null);
+    }
+}
+function esmImport(id) {
+    const module = getOrInstantiateModuleFromParent(id, this.m);
+    // any ES module has to have `module.namespaceObject` defined.
+    if (module.namespaceObject) return module.namespaceObject;
+    // only ESM can be an async module, so we don't need to worry about exports being a promise here.
+    const raw = module.exports;
+    return module.namespaceObject = interopEsm(raw, createNS(raw), raw && raw.__esModule);
+}
+contextPrototype.i = esmImport;
+function asyncLoader(moduleId) {
+    const loader = this.r(moduleId);
+    return loader(esmImport.bind(this));
+}
+contextPrototype.A = asyncLoader;
+// Add a simple runtime require so that environments without one can still pass
+// `typeof require` CommonJS checks so that exports are correctly registered.
+const runtimeRequire = // @ts-ignore
+typeof require === 'function' ? require : function require1() {
+    throw new Error('Unexpected use of runtime require');
+};
+contextPrototype.t = runtimeRequire;
+function commonJsRequire(id) {
+    return getOrInstantiateModuleFromParent(id, this.m).exports;
+}
+contextPrototype.r = commonJsRequire;
+/**
+ * Remove fragments and query parameters since they are never part of the context map keys
+ *
+ * This matches how we parse patterns at resolving time.  Arguably we should only do this for
+ * strings passed to `import` but the resolve does it for `import` and `require` and so we do
+ * here as well.
+ */ function parseRequest(request) {
+    // Per the URI spec fragments can contain `?` characters, so we should trim it off first
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    const hashIndex = request.indexOf('#');
+    if (hashIndex !== -1) {
+        request = request.substring(0, hashIndex);
+    }
+    const queryIndex = request.indexOf('?');
+    if (queryIndex !== -1) {
+        request = request.substring(0, queryIndex);
+    }
+    return request;
+}
+/**
+ * `require.context` and require/import expression runtime.
+ */ function moduleContext(map) {
+    function moduleContext(id) {
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].module();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    }
+    moduleContext.keys = ()=>{
+        return Object.keys(map);
+    };
+    moduleContext.resolve = (id)=>{
+        id = parseRequest(id);
+        if (hasOwnProperty.call(map, id)) {
+            return map[id].id();
+        }
+        const e = new Error(`Cannot find module '${id}'`);
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+    };
+    moduleContext.import = async (id)=>{
+        return await moduleContext(id);
+    };
+    return moduleContext;
+}
+contextPrototype.f = moduleContext;
+/**
+ * Returns the path of a chunk defined by its data.
+ */ function getChunkPath(chunkData) {
+    return typeof chunkData === 'string' ? chunkData : chunkData.path;
+}
+function isPromise(maybePromise) {
+    return maybePromise != null && typeof maybePromise === 'object' && 'then' in maybePromise && typeof maybePromise.then === 'function';
+}
+function isAsyncModuleExt(obj) {
+    return turbopackQueues in obj;
+}
+function createPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        reject = rej;
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+// Load the CompressedmoduleFactories of a chunk into the `moduleFactories` Map.
+// The CompressedModuleFactories format is
+// - 1 or more module ids
+// - a module factory function
+// So walking this is a little complex but the flat structure is also fast to
+// traverse, we can use `typeof` operators to distinguish the two cases.
+function installCompressedModuleFactories(chunkModules, offset, moduleFactories, newModuleId) {
+    let i = offset;
+    while(i < chunkModules.length){
+        let moduleId = chunkModules[i];
+        let end = i + 1;
+        // Find our factory function
+        while(end < chunkModules.length && typeof chunkModules[end] !== 'function'){
+            end++;
+        }
+        if (end === chunkModules.length) {
+            throw new Error('malformed chunk format, expected a factory function');
+        }
+        // Each chunk item has a 'primary id' and optional additional ids. If the primary id is already
+        // present we know all the additional ids are also present, so we don't need to check.
+        if (!moduleFactories.has(moduleId)) {
+            const moduleFactoryFn = chunkModules[end];
+            applyModuleFactoryName(moduleFactoryFn);
+            newModuleId?.(moduleId);
+            for(; i < end; i++){
+                moduleId = chunkModules[i];
+                moduleFactories.set(moduleId, moduleFactoryFn);
+            }
+        }
+        i = end + 1; // end is pointing at the last factory advance to the next id or the end of the array.
+    }
+}
+// everything below is adapted from webpack
+// https://github.com/webpack/webpack/blob/6be4065ade1e252c1d8dcba4af0f43e32af1bdc1/lib/runtime/AsyncModuleRuntimeModule.js#L13
+const turbopackQueues = Symbol('turbopack queues');
+const turbopackExports = Symbol('turbopack exports');
+const turbopackError = Symbol('turbopack error');
+function resolveQueue(queue) {
+    if (queue && queue.status !== 1) {
+        queue.status = 1;
+        queue.forEach((fn)=>fn.queueCount--);
+        queue.forEach((fn)=>fn.queueCount-- ? fn.queueCount++ : fn());
+    }
+}
+function wrapDeps(deps) {
+    return deps.map((dep)=>{
+        if (dep !== null && typeof dep === 'object') {
+            if (isAsyncModuleExt(dep)) return dep;
+            if (isPromise(dep)) {
+                const queue = Object.assign([], {
+                    status: 0
+                });
+                const obj = {
+                    [turbopackExports]: {},
+                    [turbopackQueues]: (fn)=>fn(queue)
+                };
+                dep.then((res)=>{
+                    obj[turbopackExports] = res;
+                    resolveQueue(queue);
+                }, (err)=>{
+                    obj[turbopackError] = err;
+                    resolveQueue(queue);
+                });
+                return obj;
+            }
+        }
+        return {
+            [turbopackExports]: dep,
+            [turbopackQueues]: ()=>{}
+        };
+    });
+}
+function asyncModule(body, hasAwait) {
+    const module = this.m;
+    const queue = hasAwait ? Object.assign([], {
+        status: -1
+    }) : undefined;
+    const depQueues = new Set();
+    const { resolve, reject, promise: rawPromise } = createPromise();
+    const promise = Object.assign(rawPromise, {
+        [turbopackExports]: module.exports,
+        [turbopackQueues]: (fn)=>{
+            queue && fn(queue);
+            depQueues.forEach(fn);
+            promise['catch'](()=>{});
+        }
+    });
+    const attributes = {
+        get () {
+            return promise;
+        },
+        set (v) {
+            // Calling `esmExport` leads to this.
+            if (v !== promise) {
+                promise[turbopackExports] = v;
+            }
+        }
+    };
+    Object.defineProperty(module, 'exports', attributes);
+    Object.defineProperty(module, 'namespaceObject', attributes);
+    function handleAsyncDependencies(deps) {
+        const currentDeps = wrapDeps(deps);
+        const getResult = ()=>currentDeps.map((d)=>{
+                if (d[turbopackError]) throw d[turbopackError];
+                return d[turbopackExports];
+            });
+        const { promise, resolve } = createPromise();
+        const fn = Object.assign(()=>resolve(getResult), {
+            queueCount: 0
+        });
+        function fnQueue(q) {
+            if (q !== queue && !depQueues.has(q)) {
+                depQueues.add(q);
+                if (q && q.status === 0) {
+                    fn.queueCount++;
+                    q.push(fn);
+                }
+            }
+        }
+        currentDeps.map((dep)=>dep[turbopackQueues](fnQueue));
+        return fn.queueCount ? promise : getResult();
+    }
+    function asyncResult(err) {
+        if (err) {
+            reject(promise[turbopackError] = err);
+        } else {
+            resolve(promise[turbopackExports]);
+        }
+        resolveQueue(queue);
+    }
+    body(handleAsyncDependencies, asyncResult);
+    if (queue && queue.status === -1) {
+        queue.status = 0;
+    }
+}
+contextPrototype.a = asyncModule;
+/**
+ * A pseudo "fake" URL object to resolve to its relative path.
+ *
+ * When UrlRewriteBehavior is set to relative, calls to the `new URL()` will construct url without base using this
+ * runtime function to generate context-agnostic urls between different rendering context, i.e ssr / client to avoid
+ * hydration mismatch.
+ *
+ * This is based on webpack's existing implementation:
+ * https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/RelativeUrlRuntimeModule.js
+ */ const relativeURL = function relativeURL(inputUrl) {
+    const realUrl = new URL(inputUrl, 'x:/');
+    const values = {};
+    for(const key in realUrl)values[key] = realUrl[key];
+    values.href = inputUrl;
+    values.pathname = inputUrl.replace(/[?#].*/, '');
+    values.origin = values.protocol = '';
+    values.toString = values.toJSON = (..._args)=>inputUrl;
+    for(const key in values)Object.defineProperty(this, key, {
+        enumerable: true,
+        configurable: true,
+        value: values[key]
+    });
+};
+relativeURL.prototype = URL.prototype;
+contextPrototype.U = relativeURL;
+/**
+ * Utility function to ensure all variants of an enum are handled.
+ */ function invariant(never, computeMessage) {
+    throw new Error(`Invariant: ${computeMessage(never)}`);
+}
+/**
+ * A stub function to make `require` available but non-functional in ESM.
+ */ function requireStub(_moduleId) {
+    throw new Error('dynamic usage of require is not supported');
+}
+contextPrototype.z = requireStub;
+// Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
+contextPrototype.g = globalThis;
+function applyModuleFactoryName(factory) {
+    // Give the module factory a nice name to improve stack traces.
+    Object.defineProperty(factory, 'name', {
+        value: 'module evaluation'
+    });
+}
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *browser* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/globals.d.ts" />
+/// <reference path="../../../shared/runtime-utils.ts" />
+// Used in WebWorkers to tell the runtime about the chunk suffix
+const browserContextPrototype = Context.prototype;
+var SourceType = /*#__PURE__*/ function(SourceType) {
+    /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */ SourceType[SourceType["Runtime"] = 0] = "Runtime";
+    /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */ SourceType[SourceType["Parent"] = 1] = "Parent";
+    /**
+   * The module was instantiated because it was included in a chunk's hot module
+   * update.
+   * SourceData is an array of ModuleIds or undefined.
+   */ SourceType[SourceType["Update"] = 2] = "Update";
+    return SourceType;
+}(SourceType || {});
+const moduleFactories = new Map();
+contextPrototype.M = moduleFactories;
+const availableModules = new Map();
+const availableModuleChunks = new Map();
+function factoryNotAvailableMessage(moduleId, sourceType, sourceData) {
+    let instantiationReason;
+    switch(sourceType){
+        case 0:
+            instantiationReason = `as a runtime entry of chunk ${sourceData}`;
+            break;
+        case 1:
+            instantiationReason = `because it was required from module ${sourceData}`;
+            break;
+        case 2:
+            instantiationReason = 'because of an HMR update';
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    return `Module ${moduleId} was instantiated ${instantiationReason}, but the module factory is not available.`;
+}
+function loadChunk(chunkData) {
+    return loadChunkInternal(1, this.m.id, chunkData);
+}
+browserContextPrototype.l = loadChunk;
+function loadInitialChunk(chunkPath, chunkData) {
+    return loadChunkInternal(0, chunkPath, chunkData);
+}
+async function loadChunkInternal(sourceType, sourceData, chunkData) {
+    if (typeof chunkData === 'string') {
+        return loadChunkPath(sourceType, sourceData, chunkData);
+    }
+    const includedList = chunkData.included || [];
+    const modulesPromises = includedList.map((included)=>{
+        if (moduleFactories.has(included)) return true;
+        return availableModules.get(included);
+    });
+    if (modulesPromises.length > 0 && modulesPromises.every((p)=>p)) {
+        // When all included items are already loaded or loading, we can skip loading ourselves
+        await Promise.all(modulesPromises);
+        return;
+    }
+    const includedModuleChunksList = chunkData.moduleChunks || [];
+    const moduleChunksPromises = includedModuleChunksList.map((included)=>{
+        // TODO(alexkirsz) Do we need this check?
+        // if (moduleFactories[included]) return true;
+        return availableModuleChunks.get(included);
+    }).filter((p)=>p);
+    let promise;
+    if (moduleChunksPromises.length > 0) {
+        // Some module chunks are already loaded or loading.
+        if (moduleChunksPromises.length === includedModuleChunksList.length) {
+            // When all included module chunks are already loaded or loading, we can skip loading ourselves
+            await Promise.all(moduleChunksPromises);
+            return;
+        }
+        const moduleChunksToLoad = new Set();
+        for (const moduleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(moduleChunk)) {
+                moduleChunksToLoad.add(moduleChunk);
+            }
+        }
+        for (const moduleChunkToLoad of moduleChunksToLoad){
+            const promise = loadChunkPath(sourceType, sourceData, moduleChunkToLoad);
+            availableModuleChunks.set(moduleChunkToLoad, promise);
+            moduleChunksPromises.push(promise);
+        }
+        promise = Promise.all(moduleChunksPromises);
+    } else {
+        promise = loadChunkPath(sourceType, sourceData, chunkData.path);
+        // Mark all included module chunks as loading if they are not already loaded or loading.
+        for (const includedModuleChunk of includedModuleChunksList){
+            if (!availableModuleChunks.has(includedModuleChunk)) {
+                availableModuleChunks.set(includedModuleChunk, promise);
+            }
+        }
+    }
+    for (const included of includedList){
+        if (!availableModules.has(included)) {
+            // It might be better to race old and new promises, but it's rare that the new promise will be faster than a request started earlier.
+            // In production it's even more rare, because the chunk optimization tries to deduplicate modules anyway.
+            availableModules.set(included, promise);
+        }
+    }
+    await promise;
+}
+const loadedChunk = Promise.resolve(undefined);
+const instrumentedBackendLoadChunks = new WeakMap();
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrl(chunkUrl) {
+    return loadChunkByUrlInternal(1, this.m.id, chunkUrl);
+}
+browserContextPrototype.L = loadChunkByUrl;
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkByUrlInternal(sourceType, sourceData, chunkUrl) {
+    const thenable = BACKEND.loadChunkCached(sourceType, chunkUrl);
+    let entry = instrumentedBackendLoadChunks.get(thenable);
+    if (entry === undefined) {
+        const resolve = instrumentedBackendLoadChunks.set.bind(instrumentedBackendLoadChunks, thenable, loadedChunk);
+        entry = thenable.then(resolve).catch((cause)=>{
+            let loadReason;
+            switch(sourceType){
+                case 0:
+                    loadReason = `as a runtime dependency of chunk ${sourceData}`;
+                    break;
+                case 1:
+                    loadReason = `from module ${sourceData}`;
+                    break;
+                case 2:
+                    loadReason = 'from an HMR update';
+                    break;
+                default:
+                    invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+            }
+            let error = new Error(`Failed to load chunk ${chunkUrl} ${loadReason}${cause ? `: ${cause}` : ''}`, cause ? {
+                cause
+            } : undefined);
+            error.name = 'ChunkLoadError';
+            throw error;
+        });
+        instrumentedBackendLoadChunks.set(thenable, entry);
+    }
+    return entry;
+}
+// Do not make this async. React relies on referential equality of the returned Promise.
+function loadChunkPath(sourceType, sourceData, chunkPath) {
+    const url = getChunkRelativeUrl(chunkPath);
+    return loadChunkByUrlInternal(sourceType, sourceData, url);
+}
+/**
+ * Returns an absolute url to an asset.
+ */ function resolvePathFromModule(moduleId) {
+    const exported = this.r(moduleId);
+    return exported?.default ?? exported;
+}
+browserContextPrototype.R = resolvePathFromModule;
+/**
+ * no-op for browser
+ * @param modulePath
+ */ function resolveAbsolutePath(modulePath) {
+    return `/ROOT/${modulePath ?? ''}`;
+}
+browserContextPrototype.P = resolveAbsolutePath;
+/**
+ * Returns a URL for the worker.
+ * The entrypoint is a pre-compiled worker runtime file. The params configure
+ * which module chunks to load and which module to run as the entry point.
+ *
+ * @param entrypoint URL path to the worker entrypoint chunk
+ * @param moduleChunks list of module chunk paths to load
+ * @param shared whether this is a SharedWorker (uses querystring for URL identity)
+ */ function getWorkerURL(entrypoint, moduleChunks, shared) {
+    const url = new URL(getChunkRelativeUrl(entrypoint), location.origin);
+    const params = {
+        S: CHUNK_SUFFIX,
+        N: globalThis.NEXT_DEPLOYMENT_ID,
+        NC: moduleChunks.map((chunk)=>getChunkRelativeUrl(chunk))
+    };
+    const paramsJson = JSON.stringify(params);
+    if (shared) {
+        url.searchParams.set('params', paramsJson);
+    } else {
+        url.hash = '#params=' + encodeURIComponent(paramsJson);
+    }
+    return url;
+}
+browserContextPrototype.b = getWorkerURL;
+/**
+ * Instantiates a runtime module.
+ */ function instantiateRuntimeModule(moduleId, chunkPath) {
+    return instantiateModule(moduleId, 0, chunkPath);
+}
+/**
+ * Returns the URL relative to the origin where a chunk can be fetched from.
+ */ function getChunkRelativeUrl(chunkPath) {
+    return `${CHUNK_BASE_PATH}${chunkPath.split('/').map((p)=>encodeURIComponent(p)).join('/')}${CHUNK_SUFFIX}`;
+}
+function getPathFromScript(chunkScript) {
+    if (typeof chunkScript === 'string') {
+        return chunkScript;
+    }
+    const chunkUrl = typeof TURBOPACK_NEXT_CHUNK_URLS !== 'undefined' ? TURBOPACK_NEXT_CHUNK_URLS.pop() : chunkScript.getAttribute('src');
+    const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''));
+    const path = src.startsWith(CHUNK_BASE_PATH) ? src.slice(CHUNK_BASE_PATH.length) : src;
+    return path;
+}
+const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.
+ */ function isJs(chunkUrlOrPath) {
+    return regexJsUrl.test(chunkUrlOrPath);
+}
+const regexCssUrl = /\.css(?:\?[^#]*)?(?:#.*)?$/;
+/**
+ * Checks if a given path/URL ends with .css, optionally followed by ?query or #fragment.
+ */ function isCss(chunkUrl) {
+    return regexCssUrl.test(chunkUrl);
+}
+function loadWebAssembly(chunkPath, edgeModule, importsObj) {
+    return BACKEND.loadWebAssembly(1, this.m.id, chunkPath, edgeModule, importsObj);
+}
+contextPrototype.w = loadWebAssembly;
+function loadWebAssemblyModule(chunkPath, edgeModule) {
+    return BACKEND.loadWebAssemblyModule(1, this.m.id, chunkPath, edgeModule);
+}
+contextPrototype.u = loadWebAssemblyModule;
+/// <reference path="./dev-globals.d.ts" />
+/// <reference path="./dev-protocol.d.ts" />
+/// <reference path="./dev-extensions.ts" />
+const devContextPrototype = Context.prototype;
+/**
+ * This file contains runtime types and functions that are shared between all
+ * Turbopack *development* ECMAScript runtimes.
+ *
+ * It will be appended to the runtime code of each runtime right after the
+ * shared runtime utils.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ const devModuleCache = Object.create(null);
+devContextPrototype.c = devModuleCache;
+class UpdateApplyError extends Error {
+    name = 'UpdateApplyError';
+    dependencyChain;
+    constructor(message, dependencyChain){
+        super(message);
+        this.dependencyChain = dependencyChain;
+    }
+}
+/**
+ * Module IDs that are instantiated as part of the runtime of a chunk.
+ */ const runtimeModules = new Set();
+/**
+ * Map from module ID to the chunks that contain this module.
+ *
+ * In HMR, we need to keep track of which modules are contained in which so
+ * chunks. This is so we don't eagerly dispose of a module when it is removed
+ * from chunk A, but still exists in chunk B.
+ */ const moduleChunksMap = new Map();
+/**
+ * Map from a chunk path to all modules it contains.
+ */ const chunkModulesMap = new Map();
+/**
+ * Chunk lists that contain a runtime. When these chunk lists receive an update
+ * that can't be reconciled with the current state of the page, we need to
+ * reload the runtime entirely.
+ */ const runtimeChunkLists = new Set();
+/**
+ * Map from a chunk list to the chunk paths it contains.
+ */ const chunkListChunksMap = new Map();
+/**
+ * Map from a chunk path to the chunk lists it belongs to.
+ */ const chunkChunkListsMap = new Map();
+/**
+ * Maps module IDs to persisted data between executions of their hot module
+ * implementation (`hot.data`).
+ */ const moduleHotData = new Map();
+/**
+ * Maps module instances to their hot module state.
+ */ const moduleHotState = new Map();
+/**
+ * Modules that call `module.hot.invalidate()` (while being updated).
+ */ const queuedInvalidatedModules = new Set();
+/**
+ * Gets or instantiates a runtime module.
+ */ // @ts-ignore
+function getOrInstantiateRuntimeModule(chunkPath, moduleId) {
+    const module = devModuleCache[moduleId];
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        return module;
+    }
+    // @ts-ignore
+    return instantiateModule(moduleId, SourceType.Runtime, chunkPath);
+}
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */ // @ts-ignore Defined in `runtime-utils.ts`
+const getOrInstantiateModuleFromParent = (id, sourceModule)=>{
+    if (!sourceModule.hot.active) {
+        console.warn(`Unexpected import of module ${id} from module ${sourceModule.id}, which was deleted by an HMR update`);
+    }
+    const module = devModuleCache[id];
+    if (sourceModule.children.indexOf(id) === -1) {
+        sourceModule.children.push(id);
+    }
+    if (module) {
+        if (module.error) {
+            throw module.error;
+        }
+        if (module.parents.indexOf(sourceModule.id) === -1) {
+            module.parents.push(sourceModule.id);
+        }
+        return module;
+    }
+    return instantiateModule(id, SourceType.Parent, sourceModule.id);
+};
+function DevContext(module, exports, refresh) {
+    Context.call(this, module, exports);
+    this.k = refresh;
+}
+DevContext.prototype = Context.prototype;
+function instantiateModule(moduleId, sourceType, sourceData) {
+    // We are in development, this is always a string.
+    let id = moduleId;
+    const moduleFactory = moduleFactories.get(id);
+    if (typeof moduleFactory !== 'function') {
+        // This can happen if modules incorrectly handle HMR disposes/updates,
+        // e.g. when they keep a `setTimeout` around which still executes old code
+        // and contains e.g. a `require("something")` call.
+        throw new Error(factoryNotAvailableMessage(id, sourceType, sourceData) + ' It might have been deleted in an HMR update.');
+    }
+    const hotData = moduleHotData.get(id);
+    const { hot, hotState } = createModuleHot(id, hotData);
+    let parents;
+    switch(sourceType){
+        case SourceType.Runtime:
+            runtimeModules.add(id);
+            parents = [];
+            break;
+        case SourceType.Parent:
+            // No need to add this module as a child of the parent module here, this
+            // has already been taken care of in `getOrInstantiateModuleFromParent`.
+            parents = [
+                sourceData
+            ];
+            break;
+        case SourceType.Update:
+            parents = sourceData || [];
+            break;
+        default:
+            invariant(sourceType, (sourceType)=>`Unknown source type: ${sourceType}`);
+    }
+    const module = createModuleObject(id);
+    const exports = module.exports;
+    module.parents = parents;
+    module.children = [];
+    module.hot = hot;
+    devModuleCache[id] = module;
+    moduleHotState.set(module, hotState);
+    // NOTE(alexkirsz) This can fail when the module encounters a runtime error.
+    try {
+        runModuleExecutionHooks(module, (refresh)=>{
+            const context = new DevContext(module, exports, refresh);
+            moduleFactory(context, module, exports);
+        });
+    } catch (error) {
+        module.error = error;
+        throw error;
+    }
+    if (module.namespaceObject && module.exports !== module.namespaceObject) {
+        // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+        interopEsm(module.exports, module.namespaceObject);
+    }
+    return module;
+}
+const DUMMY_REFRESH_CONTEXT = {
+    register: (_type, _id)=>{},
+    signature: ()=>(_type)=>{},
+    registerExports: (_module, _helpers)=>{}
+};
+/**
+ * NOTE(alexkirsz) Webpack has a "module execution" interception hook that
+ * Next.js' React Refresh runtime hooks into to add module context to the
+ * refresh registry.
+ */ function runModuleExecutionHooks(module, executeModule) {
+    if (typeof globalThis.$RefreshInterceptModuleExecution$ === 'function') {
+        const cleanupReactRefreshIntercept = globalThis.$RefreshInterceptModuleExecution$(module.id);
+        try {
+            executeModule({
+                register: globalThis.$RefreshReg$,
+                signature: globalThis.$RefreshSig$,
+                registerExports: registerExportsAndSetupBoundaryForReactRefresh
+            });
+        } finally{
+            // Always cleanup the intercept, even if module execution failed.
+            cleanupReactRefreshIntercept();
+        }
+    } else {
+        // If the react refresh hooks are not installed we need to bind dummy functions.
+        // This is expected when running in a Web Worker.  It is also common in some of
+        // our test environments.
+        executeModule(DUMMY_REFRESH_CONTEXT);
+    }
+}
+/**
+ * This is adapted from https://github.com/vercel/next.js/blob/3466862d9dc9c8bb3131712134d38757b918d1c0/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+ */ function registerExportsAndSetupBoundaryForReactRefresh(module, helpers) {
+    const currentExports = module.exports;
+    const prevExports = module.hot.data.prevExports ?? null;
+    helpers.registerExportsForReactRefresh(currentExports, module.id);
+    // A module can be accepted automatically based on its exports, e.g. when
+    // it is a Refresh Boundary.
+    if (helpers.isReactRefreshBoundary(currentExports)) {
+        // Save the previous exports on update, so we can compare the boundary
+        // signatures.
+        module.hot.dispose((data)=>{
+            data.prevExports = currentExports;
+        });
+        // Unconditionally accept an update to this module, we'll check if it's
+        // still a Refresh Boundary later.
+        module.hot.accept();
+        // This field is set when the previous version of this module was a
+        // Refresh Boundary, letting us know we need to check for invalidation or
+        // enqueue an update.
+        if (prevExports !== null) {
+            // A boundary can become ineligible if its exports are incompatible
+            // with the previous exports.
+            //
+            // For example, if you add/remove/change exports, we'll want to
+            // re-execute the importing modules, and force those components to
+            // re-render. Similarly, if you convert a class component to a
+            // function, we want to invalidate the boundary.
+            if (helpers.shouldInvalidateReactRefreshBoundary(helpers.getRefreshBoundarySignature(prevExports), helpers.getRefreshBoundarySignature(currentExports))) {
+                module.hot.invalidate();
+            } else {
+                helpers.scheduleUpdate();
+            }
+        }
+    } else {
+        // Since we just executed the code for the module, it's possible that the
+        // new exports made it ineligible for being a boundary.
+        // We only care about the case when we were _previously_ a boundary,
+        // because we already accepted this update (accidental side effect).
+        const isNoLongerABoundary = prevExports !== null;
+        if (isNoLongerABoundary) {
+            module.hot.invalidate();
+        }
+    }
+}
+function formatDependencyChain(dependencyChain) {
+    return `Dependency chain: ${dependencyChain.join(' -> ')}`;
+}
+function computeOutdatedModules(added, modified) {
+    const newModuleFactories = new Map();
+    for (const [moduleId, entry] of added){
+        if (entry != null) {
+            newModuleFactories.set(moduleId, _eval(entry));
+        }
+    }
+    const outdatedModules = computedInvalidatedModules(modified.keys());
+    for (const [moduleId, entry] of modified){
+        newModuleFactories.set(moduleId, _eval(entry));
+    }
+    return {
+        outdatedModules,
+        newModuleFactories
+    };
+}
+function computedInvalidatedModules(invalidated) {
+    const outdatedModules = new Set();
+    for (const moduleId of invalidated){
+        const effect = getAffectedModuleEffects(moduleId);
+        switch(effect.type){
+            case 'unaccepted':
+                throw new UpdateApplyError(`cannot apply update: unaccepted module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'self-declined':
+                throw new UpdateApplyError(`cannot apply update: self-declined module. ${formatDependencyChain(effect.dependencyChain)}.`, effect.dependencyChain);
+            case 'accepted':
+                for (const outdatedModuleId of effect.outdatedModules){
+                    outdatedModules.add(outdatedModuleId);
+                }
+                break;
+            // TODO(alexkirsz) Dependencies: handle dependencies effects.
+            default:
+                invariant(effect, (effect)=>`Unknown effect type: ${effect?.type}`);
+        }
+    }
+    return outdatedModules;
+}
+function computeOutdatedSelfAcceptedModules(outdatedModules) {
+    const outdatedSelfAcceptedModules = [];
+    for (const moduleId of outdatedModules){
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (module && hotState.selfAccepted && !hotState.selfInvalidated) {
+            outdatedSelfAcceptedModules.push({
+                moduleId,
+                errorHandler: hotState.selfAccepted
+            });
+        }
+    }
+    return outdatedSelfAcceptedModules;
+}
+/**
+ * Adds, deletes, and moves modules between chunks. This must happen before the
+ * dispose phase as it needs to know which modules were removed from all chunks,
+ * which we can only compute *after* taking care of added and moved modules.
+ */ function updateChunksPhase(chunksAddedModules, chunksDeletedModules) {
+    for (const [chunkPath, addedModuleIds] of chunksAddedModules){
+        for (const moduleId of addedModuleIds){
+            addModuleToChunk(moduleId, chunkPath);
+        }
+    }
+    const disposedModules = new Set();
+    for (const [chunkPath, addedModuleIds] of chunksDeletedModules){
+        for (const moduleId of addedModuleIds){
+            if (removeModuleFromChunk(moduleId, chunkPath)) {
+                disposedModules.add(moduleId);
+            }
+        }
+    }
+    return {
+        disposedModules
+    };
+}
+function disposePhase(outdatedModules, disposedModules) {
+    for (const moduleId of outdatedModules){
+        disposeModule(moduleId, 'replace');
+    }
+    for (const moduleId of disposedModules){
+        disposeModule(moduleId, 'clear');
+    }
+    // Removing modules from the module cache is a separate step.
+    // We also want to keep track of previous parents of the outdated modules.
+    const outdatedModuleParents = new Map();
+    for (const moduleId of outdatedModules){
+        const oldModule = devModuleCache[moduleId];
+        outdatedModuleParents.set(moduleId, oldModule?.parents);
+        delete devModuleCache[moduleId];
+    }
+    // TODO(alexkirsz) Dependencies: remove outdated dependency from module
+    // children.
+    return {
+        outdatedModuleParents
+    };
+}
+/**
+ * Disposes of an instance of a module.
+ *
+ * Returns the persistent hot data that should be kept for the next module
+ * instance.
+ *
+ * NOTE: mode = "replace" will not remove modules from the devModuleCache
+ * This must be done in a separate step afterwards.
+ * This is important because all modules need to be disposed to update the
+ * parent/child relationships before they are actually removed from the devModuleCache.
+ * If this was done in this method, the following disposeModule calls won't find
+ * the module from the module id in the cache.
+ */ function disposeModule(moduleId, mode) {
+    const module = devModuleCache[moduleId];
+    if (!module) {
+        return;
+    }
+    const hotState = moduleHotState.get(module);
+    const data = {};
+    // Run the `hot.dispose` handler, if any, passing in the persistent
+    // `hot.data` object.
+    for (const disposeHandler of hotState.disposeHandlers){
+        disposeHandler(data);
+    }
+    // This used to warn in `getOrInstantiateModuleFromParent` when a disposed
+    // module is still importing other modules.
+    module.hot.active = false;
+    moduleHotState.delete(module);
+    // TODO(alexkirsz) Dependencies: delete the module from outdated deps.
+    // Remove the disposed module from its children's parent list.
+    // It will be added back once the module re-instantiates and imports its
+    // children again.
+    for (const childId of module.children){
+        const child = devModuleCache[childId];
+        if (!child) {
+            continue;
+        }
+        const idx = child.parents.indexOf(module.id);
+        if (idx >= 0) {
+            child.parents.splice(idx, 1);
+        }
+    }
+    switch(mode){
+        case 'clear':
+            delete devModuleCache[module.id];
+            moduleHotData.delete(module.id);
+            break;
+        case 'replace':
+            moduleHotData.set(module.id, data);
+            break;
+        default:
+            invariant(mode, (mode)=>`invalid mode: ${mode}`);
+    }
+}
+function applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError) {
+    // Update module factories.
+    for (const [moduleId, factory] of newModuleFactories.entries()){
+        applyModuleFactoryName(factory);
+        moduleFactories.set(moduleId, factory);
+    }
+    // TODO(alexkirsz) Run new runtime entries here.
+    // TODO(alexkirsz) Dependencies: call accept handlers for outdated deps.
+    // Re-instantiate all outdated self-accepted modules.
+    for (const { moduleId, errorHandler } of outdatedSelfAcceptedModules){
+        try {
+            instantiateModule(moduleId, SourceType.Update, outdatedModuleParents.get(moduleId));
+        } catch (err) {
+            if (typeof errorHandler === 'function') {
+                try {
+                    errorHandler(err, {
+                        moduleId,
+                        module: devModuleCache[moduleId]
+                    });
+                } catch (err2) {
+                    reportError(err2);
+                    reportError(err);
+                }
+            } else {
+                reportError(err);
+            }
+        }
+    }
+}
+function applyUpdate(update) {
+    switch(update.type){
+        case 'ChunkListUpdate':
+            applyChunkListUpdate(update);
+            break;
+        default:
+            invariant(update, (update)=>`Unknown update type: ${update.type}`);
+    }
+}
+function applyChunkListUpdate(update) {
+    if (update.merged != null) {
+        for (const merged of update.merged){
+            switch(merged.type){
+                case 'EcmascriptMergedUpdate':
+                    applyEcmascriptMergedUpdate(merged);
+                    break;
+                default:
+                    invariant(merged, (merged)=>`Unknown merged type: ${merged.type}`);
+            }
+        }
+    }
+    if (update.chunks != null) {
+        for (const [chunkPath, chunkUpdate] of Object.entries(update.chunks)){
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            switch(chunkUpdate.type){
+                case 'added':
+                    BACKEND.loadChunkCached(SourceType.Update, chunkUrl);
+                    break;
+                case 'total':
+                    DEV_BACKEND.reloadChunk?.(chunkUrl);
+                    break;
+                case 'deleted':
+                    DEV_BACKEND.unloadChunk?.(chunkUrl);
+                    break;
+                case 'partial':
+                    invariant(chunkUpdate.instruction, (instruction)=>`Unknown partial instruction: ${JSON.stringify(instruction)}.`);
+                    break;
+                default:
+                    invariant(chunkUpdate, (chunkUpdate)=>`Unknown chunk update type: ${chunkUpdate.type}`);
+            }
+        }
+    }
+}
+function applyEcmascriptMergedUpdate(update) {
+    const { entries = {}, chunks = {} } = update;
+    const { added, modified, chunksAdded, chunksDeleted } = computeChangedModules(entries, chunks);
+    const { outdatedModules, newModuleFactories } = computeOutdatedModules(added, modified);
+    const { disposedModules } = updateChunksPhase(chunksAdded, chunksDeleted);
+    applyInternal(outdatedModules, disposedModules, newModuleFactories);
+}
+function applyInvalidatedModules(outdatedModules) {
+    if (queuedInvalidatedModules.size > 0) {
+        computedInvalidatedModules(queuedInvalidatedModules).forEach((moduleId)=>{
+            outdatedModules.add(moduleId);
+        });
+        queuedInvalidatedModules.clear();
+    }
+    return outdatedModules;
+}
+function applyInternal(outdatedModules, disposedModules, newModuleFactories) {
+    outdatedModules = applyInvalidatedModules(outdatedModules);
+    const outdatedSelfAcceptedModules = computeOutdatedSelfAcceptedModules(outdatedModules);
+    const { outdatedModuleParents } = disposePhase(outdatedModules, disposedModules);
+    // we want to continue on error and only throw the error after we tried applying all updates
+    let error;
+    function reportError(err) {
+        if (!error) error = err;
+    }
+    applyPhase(outdatedSelfAcceptedModules, newModuleFactories, outdatedModuleParents, reportError);
+    if (error) {
+        throw error;
+    }
+    if (queuedInvalidatedModules.size > 0) {
+        applyInternal(new Set(), [], new Map());
+    }
+}
+function computeChangedModules(entries, updates) {
+    const chunksAdded = new Map();
+    const chunksDeleted = new Map();
+    const added = new Map();
+    const modified = new Map();
+    const deleted = new Set();
+    for (const [chunkPath, mergedChunkUpdate] of Object.entries(updates)){
+        switch(mergedChunkUpdate.type){
+            case 'added':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.modules);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    break;
+                }
+            case 'deleted':
+                {
+                    // We could also use `mergedChunkUpdate.modules` here.
+                    const updateDeleted = new Set(chunkModulesMap.get(chunkPath));
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            case 'partial':
+                {
+                    const updateAdded = new Set(mergedChunkUpdate.added);
+                    const updateDeleted = new Set(mergedChunkUpdate.deleted);
+                    for (const moduleId of updateAdded){
+                        added.set(moduleId, entries[moduleId]);
+                    }
+                    for (const moduleId of updateDeleted){
+                        deleted.add(moduleId);
+                    }
+                    chunksAdded.set(chunkPath, updateAdded);
+                    chunksDeleted.set(chunkPath, updateDeleted);
+                    break;
+                }
+            default:
+                invariant(mergedChunkUpdate, (mergedChunkUpdate)=>`Unknown merged chunk update type: ${mergedChunkUpdate.type}`);
+        }
+    }
+    // If a module was added from one chunk and deleted from another in the same update,
+    // consider it to be modified, as it means the module was moved from one chunk to another
+    // AND has new code in a single update.
+    for (const moduleId of added.keys()){
+        if (deleted.has(moduleId)) {
+            added.delete(moduleId);
+            deleted.delete(moduleId);
+        }
+    }
+    for (const [moduleId, entry] of Object.entries(entries)){
+        // Modules that haven't been added to any chunk but have new code are considered
+        // to be modified.
+        // This needs to be under the previous loop, as we need it to get rid of modules
+        // that were added and deleted in the same update.
+        if (!added.has(moduleId)) {
+            modified.set(moduleId, entry);
+        }
+    }
+    return {
+        added,
+        deleted,
+        modified,
+        chunksAdded,
+        chunksDeleted
+    };
+}
+function getAffectedModuleEffects(moduleId) {
+    const outdatedModules = new Set();
+    const queue = [
+        {
+            moduleId,
+            dependencyChain: []
+        }
+    ];
+    let nextItem;
+    while(nextItem = queue.shift()){
+        const { moduleId, dependencyChain } = nextItem;
+        if (moduleId != null) {
+            if (outdatedModules.has(moduleId)) {
+                continue;
+            }
+            outdatedModules.add(moduleId);
+        }
+        // We've arrived at the runtime of the chunk, which means that nothing
+        // else above can accept this update.
+        if (moduleId === undefined) {
+            return {
+                type: 'unaccepted',
+                dependencyChain
+            };
+        }
+        const module = devModuleCache[moduleId];
+        const hotState = moduleHotState.get(module);
+        if (// The module is not in the cache. Since this is a "modified" update,
+        // it means that the module was never instantiated before.
+        !module || hotState.selfAccepted && !hotState.selfInvalidated) {
+            continue;
+        }
+        if (hotState.selfDeclined) {
+            return {
+                type: 'self-declined',
+                dependencyChain,
+                moduleId
+            };
+        }
+        if (runtimeModules.has(moduleId)) {
+            queue.push({
+                moduleId: undefined,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+            continue;
+        }
+        for (const parentId of module.parents){
+            const parent = devModuleCache[parentId];
+            if (!parent) {
+                continue;
+            }
+            // TODO(alexkirsz) Dependencies: check accepted and declined
+            // dependencies here.
+            queue.push({
+                moduleId: parentId,
+                dependencyChain: [
+                    ...dependencyChain,
+                    moduleId
+                ]
+            });
+        }
+    }
+    return {
+        type: 'accepted',
+        moduleId,
+        outdatedModules
+    };
+}
+function handleApply(chunkListPath, update) {
+    switch(update.type){
+        case 'partial':
+            {
+                // This indicates that the update is can be applied to the current state of the application.
+                applyUpdate(update.instruction);
+                break;
+            }
+        case 'restart':
+            {
+                // This indicates that there is no way to apply the update to the
+                // current state of the application, and that the application must be
+                // restarted.
+                DEV_BACKEND.restart();
+                break;
+            }
+        case 'notFound':
+            {
+                // This indicates that the chunk list no longer exists: either the dynamic import which created it was removed,
+                // or the page itself was deleted.
+                // If it is a dynamic import, we simply discard all modules that the chunk has exclusive access to.
+                // If it is a runtime chunk list, we restart the application.
+                if (runtimeChunkLists.has(chunkListPath)) {
+                    DEV_BACKEND.restart();
+                } else {
+                    disposeChunkList(chunkListPath);
+                }
+                break;
+            }
+        default:
+            throw new Error(`Unknown update type: ${update.type}`);
+    }
+}
+function createModuleHot(moduleId, hotData) {
+    const hotState = {
+        selfAccepted: false,
+        selfDeclined: false,
+        selfInvalidated: false,
+        disposeHandlers: []
+    };
+    const hot = {
+        // TODO(alexkirsz) This is not defined in the HMR API. It was used to
+        // decide whether to warn whenever an HMR-disposed module required other
+        // modules. We might want to remove it.
+        active: true,
+        data: hotData ?? {},
+        // TODO(alexkirsz) Support full (dep, callback, errorHandler) form.
+        accept: (modules, _callback, _errorHandler)=>{
+            if (modules === undefined) {
+                hotState.selfAccepted = true;
+            } else if (typeof modules === 'function') {
+                hotState.selfAccepted = modules;
+            } else {
+                throw new Error('unsupported `accept` signature');
+            }
+        },
+        decline: (dep)=>{
+            if (dep === undefined) {
+                hotState.selfDeclined = true;
+            } else {
+                throw new Error('unsupported `decline` signature');
+            }
+        },
+        dispose: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        addDisposeHandler: (callback)=>{
+            hotState.disposeHandlers.push(callback);
+        },
+        removeDisposeHandler: (callback)=>{
+            const idx = hotState.disposeHandlers.indexOf(callback);
+            if (idx >= 0) {
+                hotState.disposeHandlers.splice(idx, 1);
+            }
+        },
+        invalidate: ()=>{
+            hotState.selfInvalidated = true;
+            queuedInvalidatedModules.add(moduleId);
+        },
+        // NOTE(alexkirsz) This is part of the management API, which we don't
+        // implement, but the Next.js React Refresh runtime uses this to decide
+        // whether to schedule an update.
+        status: ()=>'idle',
+        // NOTE(alexkirsz) Since we always return "idle" for now, these are no-ops.
+        addStatusHandler: (_handler)=>{},
+        removeStatusHandler: (_handler)=>{},
+        // NOTE(jridgewell) Check returns the list of updated modules, but we don't
+        // want the webpack code paths to ever update (the turbopack paths handle
+        // this already).
+        check: ()=>Promise.resolve(null)
+    };
+    return {
+        hot,
+        hotState
+    };
+}
+/**
+ * Removes a module from a chunk.
+ * Returns `true` if there are no remaining chunks including this module.
+ */ function removeModuleFromChunk(moduleId, chunkPath) {
+    const moduleChunks = moduleChunksMap.get(moduleId);
+    moduleChunks.delete(chunkPath);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    chunkModules.delete(moduleId);
+    const noRemainingModules = chunkModules.size === 0;
+    if (noRemainingModules) {
+        chunkModulesMap.delete(chunkPath);
+    }
+    const noRemainingChunks = moduleChunks.size === 0;
+    if (noRemainingChunks) {
+        moduleChunksMap.delete(moduleId);
+    }
+    return noRemainingChunks;
+}
+/**
+ * Disposes of a chunk list and its corresponding exclusive chunks.
+ */ function disposeChunkList(chunkListPath) {
+    const chunkPaths = chunkListChunksMap.get(chunkListPath);
+    if (chunkPaths == null) {
+        return false;
+    }
+    chunkListChunksMap.delete(chunkListPath);
+    for (const chunkPath of chunkPaths){
+        const chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        chunkChunkLists.delete(chunkListPath);
+        if (chunkChunkLists.size === 0) {
+            chunkChunkListsMap.delete(chunkPath);
+            disposeChunk(chunkPath);
+        }
+    }
+    // We must also dispose of the chunk list's chunk itself to ensure it may
+    // be reloaded properly in the future.
+    const chunkListUrl = getChunkRelativeUrl(chunkListPath);
+    DEV_BACKEND.unloadChunk?.(chunkListUrl);
+    return true;
+}
+/**
+ * Disposes of a chunk and its corresponding exclusive modules.
+ *
+ * @returns Whether the chunk was disposed of.
+ */ function disposeChunk(chunkPath) {
+    const chunkUrl = getChunkRelativeUrl(chunkPath);
+    // This should happen whether the chunk has any modules in it or not.
+    // For instance, CSS chunks have no modules in them, but they still need to be unloaded.
+    DEV_BACKEND.unloadChunk?.(chunkUrl);
+    const chunkModules = chunkModulesMap.get(chunkPath);
+    if (chunkModules == null) {
+        return false;
+    }
+    chunkModules.delete(chunkPath);
+    for (const moduleId of chunkModules){
+        const moduleChunks = moduleChunksMap.get(moduleId);
+        moduleChunks.delete(chunkPath);
+        const noRemainingChunks = moduleChunks.size === 0;
+        if (noRemainingChunks) {
+            moduleChunksMap.delete(moduleId);
+            disposeModule(moduleId, 'clear');
+            availableModules.delete(moduleId);
+        }
+    }
+    return true;
+}
+/**
+ * Adds a module to a chunk.
+ */ function addModuleToChunk(moduleId, chunkPath) {
+    let moduleChunks = moduleChunksMap.get(moduleId);
+    if (!moduleChunks) {
+        moduleChunks = new Set([
+            chunkPath
+        ]);
+        moduleChunksMap.set(moduleId, moduleChunks);
+    } else {
+        moduleChunks.add(chunkPath);
+    }
+    let chunkModules = chunkModulesMap.get(chunkPath);
+    if (!chunkModules) {
+        chunkModules = new Set([
+            moduleId
+        ]);
+        chunkModulesMap.set(chunkPath, chunkModules);
+    } else {
+        chunkModules.add(moduleId);
+    }
+}
+/**
+ * Marks a chunk list as a runtime chunk list. There can be more than one
+ * runtime chunk list. For instance, integration tests can have multiple chunk
+ * groups loaded at runtime, each with its own chunk list.
+ */ function markChunkListAsRuntime(chunkListPath) {
+    runtimeChunkLists.add(chunkListPath);
+}
+function registerChunk(registration) {
+    const chunkPath = getPathFromScript(registration[0]);
+    let runtimeParams;
+    // When bootstrapping we are passed a single runtimeParams object so we can distinguish purely based on length
+    if (registration.length === 2) {
+        runtimeParams = registration[1];
+    } else {
+        runtimeParams = undefined;
+        installCompressedModuleFactories(registration, /* offset= */ 1, moduleFactories, (id)=>addModuleToChunk(id, chunkPath));
+    }
+    return BACKEND.registerChunk(chunkPath, runtimeParams);
+}
+/**
+ * Subscribes to chunk list updates from the update server and applies them.
+ */ function registerChunkList(chunkList) {
+    const chunkListScript = chunkList.script;
+    const chunkListPath = getPathFromScript(chunkListScript);
+    // The "chunk" is also registered to finish the loading in the backend
+    BACKEND.registerChunk(chunkListPath);
+    globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS.push([
+        chunkListPath,
+        handleApply.bind(null, chunkListPath)
+    ]);
+    // Adding chunks to chunk lists and vice versa.
+    const chunkPaths = new Set(chunkList.chunks.map(getChunkPath));
+    chunkListChunksMap.set(chunkListPath, chunkPaths);
+    for (const chunkPath of chunkPaths){
+        let chunkChunkLists = chunkChunkListsMap.get(chunkPath);
+        if (!chunkChunkLists) {
+            chunkChunkLists = new Set([
+                chunkListPath
+            ]);
+            chunkChunkListsMap.set(chunkPath, chunkChunkLists);
+        } else {
+            chunkChunkLists.add(chunkListPath);
+        }
+    }
+    if (chunkList.source === 'entry') {
+        markChunkListAsRuntime(chunkListPath);
+    }
+}
+globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
+/**
+ * This file contains the runtime code specific to the Turbopack ECMAScript DOM runtime.
+ *
+ * It will be appended to the base runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../../../browser/runtime/base/runtime-base.ts" />
+/// <reference path="../../../shared/runtime-types.d.ts" />
+function getChunkSuffixFromScriptSrc() {
+    // TURBOPACK_CHUNK_SUFFIX is set in web workers
+    return (self.TURBOPACK_CHUNK_SUFFIX ?? document?.currentScript?.getAttribute?.('src')?.replace(/^(.*(?=\?)|^.*$)/, '')) || '';
+}
+let BACKEND;
+/**
+ * Maps chunk paths to the corresponding resolver.
+ */ const chunkResolvers = new Map();
+(()=>{
+    BACKEND = {
+        async registerChunk (chunkPath, params) {
+            const chunkUrl = getChunkRelativeUrl(chunkPath);
+            const resolver = getOrCreateResolver(chunkUrl);
+            resolver.resolve();
+            if (params == null) {
+                return;
+            }
+            for (const otherChunkData of params.otherChunks){
+                const otherChunkPath = getChunkPath(otherChunkData);
+                const otherChunkUrl = getChunkRelativeUrl(otherChunkPath);
+                // Chunk might have started loading, so we want to avoid triggering another load.
+                getOrCreateResolver(otherChunkUrl);
+            }
+            // This waits for chunks to be loaded, but also marks included items as available.
+            await Promise.all(params.otherChunks.map((otherChunkData)=>loadInitialChunk(chunkPath, otherChunkData)));
+            if (params.runtimeModuleIds.length > 0) {
+                for (const moduleId of params.runtimeModuleIds){
+                    getOrInstantiateRuntimeModule(chunkPath, moduleId);
+                }
+            }
+        },
+        /**
+     * Loads the given chunk, and returns a promise that resolves once the chunk
+     * has been loaded.
+     */ loadChunkCached (sourceType, chunkUrl) {
+            return doLoadChunk(sourceType, chunkUrl);
+        },
+        async loadWebAssembly (_sourceType, _sourceData, wasmChunkPath, _edgeModule, importsObj) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            const { instance } = await WebAssembly.instantiateStreaming(req, importsObj);
+            return instance.exports;
+        },
+        async loadWebAssemblyModule (_sourceType, _sourceData, wasmChunkPath, _edgeModule) {
+            const req = fetchWebAssembly(wasmChunkPath);
+            return await WebAssembly.compileStreaming(req);
+        }
+    };
+    function getOrCreateResolver(chunkUrl) {
+        let resolver = chunkResolvers.get(chunkUrl);
+        if (!resolver) {
+            let resolve;
+            let reject;
+            const promise = new Promise((innerResolve, innerReject)=>{
+                resolve = innerResolve;
+                reject = innerReject;
+            });
+            resolver = {
+                resolved: false,
+                loadingStarted: false,
+                promise,
+                resolve: ()=>{
+                    resolver.resolved = true;
+                    resolve();
+                },
+                reject: reject
+            };
+            chunkResolvers.set(chunkUrl, resolver);
+        }
+        return resolver;
+    }
+    /**
+   * Loads the given chunk, and returns a promise that resolves once the chunk
+   * has been loaded.
+   */ function doLoadChunk(sourceType, chunkUrl) {
+        const resolver = getOrCreateResolver(chunkUrl);
+        if (resolver.loadingStarted) {
+            return resolver.promise;
+        }
+        if (sourceType === SourceType.Runtime) {
+            // We don't need to load chunks references from runtime code, as they're already
+            // present in the DOM.
+            resolver.loadingStarted = true;
+            if (isCss(chunkUrl)) {
+                // CSS chunks do not register themselves, and as such must be marked as
+                // loaded instantly.
+                resolver.resolve();
+            }
+            // We need to wait for JS chunks to register themselves within `registerChunk`
+            // before we can start instantiating runtime modules, hence the absence of
+            // `resolver.resolve()` in this branch.
+            return resolver.promise;
+        }
+        if (typeof importScripts === 'function') {
+            // We're in a web worker
+            if (isCss(chunkUrl)) {
+            // ignore
+            } else if (isJs(chunkUrl)) {
+                self.TURBOPACK_NEXT_CHUNK_URLS.push(chunkUrl);
+                importScripts(chunkUrl);
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);
+            }
+        } else {
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length > 0) {
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolver.resolve();
+                } else {
+                    const link = document.createElement('link');
+                    link.rel = 'stylesheet';
+                    link.href = chunkUrl;
+                    link.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    link.onload = ()=>{
+                        // CSS chunks do not register themselves, and as such must be marked as
+                        // loaded instantly.
+                        resolver.resolve();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(link);
+                }
+            } else if (isJs(chunkUrl)) {
+                const previousScripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                if (previousScripts.length > 0) {
+                    // There is this edge where the script already failed loading, but we
+                    // can't detect that. The Promise will never resolve in this case.
+                    for (const script of Array.from(previousScripts)){
+                        script.addEventListener('error', ()=>{
+                            resolver.reject();
+                        });
+                    }
+                } else {
+                    const script = document.createElement('script');
+                    script.src = chunkUrl;
+                    // We'll only mark the chunk as loaded once the script has been executed,
+                    // which happens in `registerChunk`. Hence the absence of `resolve()` in
+                    // this branch.
+                    script.onerror = ()=>{
+                        resolver.reject();
+                    };
+                    // Append to the `head` for webpack compatibility.
+                    document.head.appendChild(script);
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        }
+        resolver.loadingStarted = true;
+        return resolver.promise;
+    }
+    function fetchWebAssembly(wasmChunkPath) {
+        return fetch(getChunkRelativeUrl(wasmChunkPath));
+    }
+})();
+/**
+ * This file contains the runtime code specific to the Turbopack development
+ * ECMAScript DOM runtime.
+ *
+ * It will be appended to the base development runtime code.
+ */ /* eslint-disable @typescript-eslint/no-unused-vars */ /// <reference path="../base/runtime-base.ts" />
+/// <reference path="../base/dev-base.ts" />
+/// <reference path="./runtime-backend-dom.ts" />
+/// <reference path="../../../shared/require-type.d.ts" />
+let DEV_BACKEND;
+(()=>{
+    DEV_BACKEND = {
+        unloadChunk (chunkUrl) {
+            deleteResolver(chunkUrl);
+            // TODO(PACK-2140): remove this once all filenames are guaranteed to be escaped.
+            const decodedChunkUrl = decodeURI(chunkUrl);
+            if (isCss(chunkUrl)) {
+                const links = document.querySelectorAll(`link[href="${chunkUrl}"],link[href^="${chunkUrl}?"],link[href="${decodedChunkUrl}"],link[href^="${decodedChunkUrl}?"]`);
+                for (const link of Array.from(links)){
+                    link.remove();
+                }
+            } else if (isJs(chunkUrl)) {
+                // Unloading a JS chunk would have no effect, as it lives in the JS
+                // runtime once evaluated.
+                // However, we still want to remove the script tag from the DOM to keep
+                // the HTML somewhat consistent from the user's perspective.
+                const scripts = document.querySelectorAll(`script[src="${chunkUrl}"],script[src^="${chunkUrl}?"],script[src="${decodedChunkUrl}"],script[src^="${decodedChunkUrl}?"]`);
+                for (const script of Array.from(scripts)){
+                    script.remove();
+                }
+            } else {
+                throw new Error(`can't infer type of chunk from URL ${chunkUrl}`);
+            }
+        },
+        reloadChunk (chunkUrl) {
+            return new Promise((resolve, reject)=>{
+                if (!isCss(chunkUrl)) {
+                    reject(new Error('The DOM backend can only reload CSS chunks'));
+                    return;
+                }
+                const decodedChunkUrl = decodeURI(chunkUrl);
+                const previousLinks = document.querySelectorAll(`link[rel=stylesheet][href="${chunkUrl}"],link[rel=stylesheet][href^="${chunkUrl}?"],link[rel=stylesheet][href="${decodedChunkUrl}"],link[rel=stylesheet][href^="${decodedChunkUrl}?"]`);
+                if (previousLinks.length === 0) {
+                    reject(new Error(`No link element found for chunk ${chunkUrl}`));
+                    return;
+                }
+                const link = document.createElement('link');
+                link.rel = 'stylesheet';
+                if (navigator.userAgent.includes('Firefox')) {
+                    // Firefox won't reload CSS files that were previously loaded on the current page,
+                    // we need to add a query param to make sure CSS is actually reloaded from the server.
+                    //
+                    // I believe this is this issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1037506
+                    //
+                    // Safari has a similar issue, but only if you have a `<link rel=preload ... />` tag
+                    // pointing to the same URL as the stylesheet: https://bugs.webkit.org/show_bug.cgi?id=187726
+                    link.href = `${chunkUrl}?ts=${Date.now()}`;
+                } else {
+                    link.href = chunkUrl;
+                }
+                link.onerror = ()=>{
+                    reject();
+                };
+                link.onload = ()=>{
+                    // First load the new CSS, then remove the old ones. This prevents visible
+                    // flickering that would happen in-between removing the previous CSS and
+                    // loading the new one.
+                    for (const previousLink of Array.from(previousLinks))previousLink.remove();
+                    // CSS chunks do not register themselves, and as such must be marked as
+                    // loaded instantly.
+                    resolve();
+                };
+                // Make sure to insert the new CSS right after the previous one, so that
+                // its precedence is higher.
+                previousLinks[0].parentElement.insertBefore(link, previousLinks[0].nextSibling);
+            });
+        },
+        restart: ()=>self.location.reload()
+    };
+    function deleteResolver(chunkUrl) {
+        chunkResolvers.delete(chunkUrl);
+    }
+})();
+function _eval({ code, url, map }) {
+    code += `\n\n//# sourceURL=${encodeURI(location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX)}`;
+    if (map) {
+        code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(// btoa doesn't handle nonlatin characters, so escape them as \x sequences
+        // See https://stackoverflow.com/a/26603875
+        unescape(encodeURIComponent(map)))}`;
+    }
+    // eslint-disable-next-line no-eval
+    return eval(code);
+}
+const chunksToRegister = globalThis.TURBOPACK;
+globalThis.TURBOPACK = { push: registerChunk };
+chunksToRegister.forEach(registerChunk);
+const chunkListsToRegister = globalThis.TURBOPACK_CHUNK_LISTS || [];
+globalThis.TURBOPACK_CHUNK_LISTS = { push: registerChunkList };
+chunkListsToRegister.forEach(registerChunkList);
+})();
+
+
+//# sourceMappingURL=aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js
new file mode 100644
index 00000000000000..5139e99238b511
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js
@@ -0,0 +1,21 @@
+(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push(["output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js",
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js (static in ecmascript)", ((__turbopack_context__) => {
+
+__turbopack_context__.v("/static/worker.35b5336b.js");}),
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js [test] (ecmascript, worker loader)", ((__turbopack_context__) => {
+
+__turbopack_context__.v(__turbopack_context__.b("output/6642e_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js", ["output/aaf3a_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_e14430d8.js","output/ba425_crates_turbopack-tests_tests_snapshot_workers_shared_input_worker_87533493.js"], true));
+}),
+"[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js [test] (ecmascript)", ((__turbopack_context__, module, exports) => {
+
+const __TURBOPACK__import$2e$meta__ = {
+    get url () {
+        return `file://${__turbopack_context__.P("turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js")}`;
+    }
+};
+const url = new __turbopack_context__.U(__turbopack_context__.r("[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js (static in ecmascript)"));
+new SharedWorker(__turbopack_context__.r("[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/worker.js [test] (ecmascript, worker loader)"));
+}),
+]);
+
+//# sourceMappingURL=turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js.map
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js.map
new file mode 100644
index 00000000000000..df59e4ea7232d1
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_input_3845375a._.js.map
@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "sections": [
+    {"offset": {"line": 10, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/input/index.js"],"sourcesContent":["const url = new URL('./worker.js', import.meta.url)\nnew SharedWorker(url)\n"],"names":["url","SharedWorker"],"mappings":";;;;;AAAA,MAAMA;AACN,IAAIC"}}]
+}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js.map
new file mode 100644
index 00000000000000..0470b96a8e80b4
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/output/turbopack_crates_turbopack-tests_tests_snapshot_workers_shared_output_2867ca5f._.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/worker-entrypoint.ts"],"sourcesContent":["/**\n * Worker entrypoint bootstrap.\n */\n\ninterface WorkerBootstrapConfig {\n  // TURBOPACK_CHUNK_SUFFIX\n  S?: string\n  // NEXT_DEPLOYMENT_ID\n  N?: string\n  // TURBOPACK_NEXT_CHUNK_URLS\n  NC?: string[]\n}\n\n;(() => {\n  function abort(message: string): never {\n    console.error(message)\n    throw new Error(message)\n  }\n\n  // Security: Ensure this code is running in a worker environment to prevent\n  // the worker entrypoint being used as an XSS gadget. If this is a worker, we\n  // know that the origin of the caller is the same as our origin.\n  if (\n    typeof (self as any)['WorkerGlobalScope'] === 'undefined' ||\n    !(self instanceof (self as any)['WorkerGlobalScope'])\n  ) {\n    abort('Worker entrypoint must be loaded in a worker context')\n  }\n\n  const url = new URL(location.href)\n\n  // Try querystring first (SharedWorker), then hash (regular Worker)\n  let paramsString = url.searchParams.get('params')\n  if (!paramsString && url.hash.startsWith('#params=')) {\n    paramsString = decodeURIComponent(url.hash.slice('#params='.length))\n  }\n\n  if (!paramsString) abort('Missing worker bootstrap config')\n\n  // Safety: this string requires that a script on the same origin has loaded\n  // this code as a module. We still don't fully trust it, so we'll validate the\n  // types and ensure that the next chunk URLs are same-origin.\n  const config: WorkerBootstrapConfig = JSON.parse(paramsString)\n\n  const TURBOPACK_CHUNK_SUFFIX = typeof config.S === 'string' ? config.S : ''\n  const NEXT_DEPLOYMENT_ID = typeof config.N === 'string' ? config.N : ''\n  // In a normal browser context, the runtime can figure out which chunk is\n  // currently executing via `document.currentScript`. Workers don't have that\n  // luxury, so we use `TURBOPACK_NEXT_CHUNK_URLS` as a stack instead\n  // (`reverse()`d below).\n  //\n  // Each chunk pops its URL off the front of the array when it runs, so we need\n  // to store them in reverse order to make sure the first chunk to execute sees\n  // its own URL at the front.\n  const TURBOPACK_NEXT_CHUNK_URLS = Array.isArray(config.NC) ? config.NC : []\n\n  Object.assign(self, {\n    TURBOPACK_CHUNK_SUFFIX,\n    TURBOPACK_NEXT_CHUNK_URLS,\n    NEXT_DEPLOYMENT_ID,\n  })\n\n  if (TURBOPACK_NEXT_CHUNK_URLS.length > 0) {\n    const scriptsToLoad: string[] = []\n    for (const chunk of TURBOPACK_NEXT_CHUNK_URLS) {\n      // Chunks are relative to the origin.\n      const chunkUrl = new URL(chunk, location.origin)\n      // Security: Only load scripts from the same origin. This prevents this\n      // worker entrypoint from being used as a gadget to load scripts from\n      // foreign origins if someone happens to find a separate XSS vector\n      // elsewhere on this origin.\n      if (chunkUrl.origin !== location.origin) {\n        abort(`Refusing to load script from foreign origin: ${chunkUrl.origin}`)\n      }\n      scriptsToLoad.push(chunkUrl.toString())\n    }\n\n    TURBOPACK_NEXT_CHUNK_URLS.reverse()\n    importScripts(...scriptsToLoad)\n  }\n})()\n"],"names":["abort","message","console","error","Error","self","url","URL","location","href","paramsString","searchParams","get","hash","startsWith","decodeURIComponent","slice","length","config","JSON","parse","TURBOPACK_CHUNK_SUFFIX","S","NEXT_DEPLOYMENT_ID","N","TURBOPACK_NEXT_CHUNK_URLS","Array","isArray","NC","Object","assign","scriptsToLoad","chunk","chunkUrl","origin","push","toString","reverse","importScripts"],"mappings":"AAAA;;CAEC;AAWA,CAAC;IACA,SAASA,MAAMC,OAAe;QAC5BC,QAAQC,KAAK,CAACF;QACd,MAAM,IAAIG,MAAMH;IAClB;IAEA,2EAA2E;IAC3E,6EAA6E;IAC7E,gEAAgE;IAChE,IACE,OAAO,AAACI,IAAY,CAAC,oBAAoB,KAAK,eAC9C,CAAC,CAACA,gBAAgB,AAACA,IAAY,CAAC,oBAAoB,GACpD;QACAL,MAAM;IACR;IAEA,MAAMM,MAAM,IAAIC,IAAIC,SAASC,IAAI;IAEjC,mEAAmE;IACnE,IAAIC,eAAeJ,IAAIK,YAAY,CAACC,GAAG,CAAC;IACxC,IAAI,CAACF,gBAAgBJ,IAAIO,IAAI,CAACC,UAAU,CAAC,aAAa;QACpDJ,eAAeK,mBAAmBT,IAAIO,IAAI,CAACG,KAAK,CAAC,WAAWC,MAAM;IACpE;IAEA,IAAI,CAACP,cAAcV,MAAM;IAEzB,2EAA2E;IAC3E,8EAA8E;IAC9E,6DAA6D;IAC7D,MAAMkB,SAAgCC,KAAKC,KAAK,CAACV;IAEjD,MAAMW,yBAAyB,OAAOH,OAAOI,CAAC,KAAK,WAAWJ,OAAOI,CAAC,GAAG;IACzE,MAAMC,qBAAqB,OAAOL,OAAOM,CAAC,KAAK,WAAWN,OAAOM,CAAC,GAAG;IACrE,yEAAyE;IACzE,4EAA4E;IAC5E,mEAAmE;IACnE,wBAAwB;IACxB,EAAE;IACF,8EAA8E;IAC9E,8EAA8E;IAC9E,4BAA4B;IAC5B,MAAMC,4BAA4BC,MAAMC,OAAO,CAACT,OAAOU,EAAE,IAAIV,OAAOU,EAAE,GAAG,EAAE;IAE3EC,OAAOC,MAAM,CAACzB,MAAM;QAClBgB;QACAI;QACAF;IACF;IAEA,IAAIE,0BAA0BR,MAAM,GAAG,GAAG;QACxC,MAAMc,gBAA0B,EAAE;QAClC,KAAK,MAAMC,SAASP,0BAA2B;YAC7C,qCAAqC;YACrC,MAAMQ,WAAW,IAAI1B,IAAIyB,OAAOxB,SAAS0B,MAAM;YAC/C,uEAAuE;YACvE,qEAAqE;YACrE,mEAAmE;YACnE,4BAA4B;YAC5B,IAAID,SAASC,MAAM,KAAK1B,SAAS0B,MAAM,EAAE;gBACvClC,MAAM,CAAC,6CAA6C,EAAEiC,SAASC,MAAM,EAAE;YACzE;YACAH,cAAcI,IAAI,CAACF,SAASG,QAAQ;QACtC;QAEAX,0BAA0BY,OAAO;QACjCC,iBAAiBP;IACnB;AACF,CAAC","ignoreList":[0]}
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/static/worker.35b5336b.js b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/static/worker.35b5336b.js
new file mode 100644
index 00000000000000..6415ddbc392371
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/workers/shared/static/worker.35b5336b.js
@@ -0,0 +1 @@
+self.onconnect = (e) => e.ports[0].postMessage('hello')
\ No newline at end of file

From 2912f102816f625434a9e388039250596231a30c Mon Sep 17 00:00:00 2001
From: Benjamin Woodruff <benjamin.woodruff@vercel.com>
Date: Wed, 21 Jan 2026 10:08:32 -0800
Subject: [PATCH 7/8] Turbopack: Add file write invalidation tracking to
 filesystem watcher fuzzing (#88665)

In addition to creating task invalidators for file reads, we also create invalidators for file writes. This extends the fuzzer to cover that.

This is a bit trickier to test. Because the `write` call doesn't return anything, the caller of `write` never gets invalidated and re-executed, even though `write` does. So instead, we must observe that `write` was re-executed by looking at the contents of the file it wrote to. We write a sentinel value to files when we call the turbo-tasks-fs `write` function, and write random values to it to trigger an invalidation.

I tested this on Windows and Linux.

I don't care about the code quality here, so this was LLM-generated with very lightweight review.
---
 turbopack/crates/turbo-tasks-fuzz/src/main.rs | 277 ++++++++++++++++--
 1 file changed, 248 insertions(+), 29 deletions(-)

diff --git a/turbopack/crates/turbo-tasks-fuzz/src/main.rs b/turbopack/crates/turbo-tasks-fuzz/src/main.rs
index 31a28ddf16d553..dcaa265a1d2bad 100644
--- a/turbopack/crates/turbo-tasks-fuzz/src/main.rs
+++ b/turbopack/crates/turbo-tasks-fuzz/src/main.rs
@@ -14,9 +14,18 @@ use rand::{Rng, RngCore, SeedableRng};
 use rustc_hash::FxHashSet;
 use tokio::time::sleep;
 use turbo_rcstr::{RcStr, rcstr};
-use turbo_tasks::{NonLocalValue, ResolvedVc, TransientInstance, Vc, trace::TraceRawVcs};
+use turbo_tasks::{
+    NonLocalValue, ResolvedVc, TransientInstance, Vc, apply_effects, trace::TraceRawVcs,
+};
 use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};
-use turbo_tasks_fs::{DiskFileSystem, FileSystem, FileSystemPath};
+use turbo_tasks_fs::{
+    DiskFileSystem, File, FileContent, FileSystem, FileSystemPath, LinkContent, LinkType,
+};
+
+// `read_or_write_all_paths_operation` always writes the sentinel values to files/symlinks. We can
+// check for these sentinel values to see if `write`/`write_link` was re-run.
+const FILE_SENTINEL_CONTENT: &[u8] = b"sentinel_value";
+const SYMLINK_SENTINEL_TARGET: &str = "../0";
 
 /// A collection of fuzzers for `turbo-tasks`. These are not test cases as they're slow and (in many
 /// cases) non-deterministic.
@@ -66,6 +75,10 @@ struct FsWatcher {
     /// Number of symlink modifications per iteration (only used when --symlinks is set).
     #[arg(long, default_value_t = 20, requires = "symlinks")]
     symlink_modifications: u32,
+    /// Track file writes instead of reads. When enabled, the fuzzer writes files via
+    /// turbo-tasks and verifies that external modifications trigger invalidations.
+    #[arg(long)]
+    track_writes: bool,
 }
 
 #[derive(Clone, Copy, Debug, ValueEnum)]
@@ -81,6 +94,17 @@ enum SymlinkMode {
     Junction,
 }
 
+impl SymlinkMode {
+    fn to_link_type(self) -> LinkType {
+        match self {
+            SymlinkMode::File => LinkType::empty(),
+            SymlinkMode::Directory => LinkType::DIRECTORY,
+            #[cfg(windows)]
+            SymlinkMode::Junction => LinkType::DIRECTORY,
+        }
+    }
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let cli = Cli::parse();
@@ -129,23 +153,46 @@ async fn fuzz_fs_watcher(args: FsWatcher) -> anyhow::Result<()> {
             project_fs.await?.start_watching(None).await?;
         }
 
-        let read_all_paths_op = read_all_paths_operation(
+        let symlink_count = if args.symlinks.is_some() {
+            args.symlink_count
+        } else {
+            0
+        };
+        let track_writes = args.track_writes;
+        let symlink_mode = args.symlinks;
+        let symlink_is_directory =
+            symlink_mode.map(|m| m.to_link_type().contains(LinkType::DIRECTORY));
+
+        let initial_op = read_or_write_all_paths_operation(
             invalidations.clone(),
             project_root.clone(),
             args.depth,
             args.width,
-            if args.symlinks.is_some() {
-                args.symlink_count
-            } else {
-                0
-            },
+            symlink_count,
+            symlink_is_directory,
+            track_writes,
         );
-        read_all_paths_op.read_strongly_consistent().await?;
-        {
-            let mut invalidations = invalidations.0.lock().unwrap();
+        initial_op.read_strongly_consistent().await?;
+        if track_writes {
+            apply_effects(initial_op).await?;
+            let (total, mismatched) = verify_written_files(
+                &fs_root,
+                args.depth,
+                args.width,
+                symlink_count,
+                symlink_mode,
+            );
+            println!("wrote all {} paths, {} mismatches", total, mismatched.len());
+            if args.print_missing_invalidations && !mismatched.is_empty() {
+                for path in &mismatched {
+                    println!("  mismatch {path:?}");
+                }
+            }
+        } else {
+            let invalidations = invalidations.0.lock().unwrap();
             println!("read all {} files", invalidations.len());
-            invalidations.clear();
         }
+        invalidations.0.lock().unwrap().clear();
 
         if args.start_watching_late {
             project_fs.await?.start_watching(None).await?;
@@ -201,14 +248,46 @@ async fn fuzz_fs_watcher(args: FsWatcher) -> anyhow::Result<()> {
             // there's no way to know when we've received all the pending events from the operating
             // system, so just sleep and pray
             sleep(Duration::from_millis(args.notify_timeout_ms)).await;
-            read_all_paths_op.read_strongly_consistent().await?;
-            {
+            let read_or_write_op = read_or_write_all_paths_operation(
+                invalidations.clone(),
+                project_root.clone(),
+                args.depth,
+                args.width,
+                symlink_count,
+                symlink_is_directory,
+                track_writes,
+            );
+            read_or_write_op.read_strongly_consistent().await?;
+            let symlink_info = if args.symlinks.is_some() {
+                " and symlinks"
+            } else {
+                ""
+            };
+            if track_writes {
+                apply_effects(read_or_write_op).await?;
+                let (total, mismatched) = verify_written_files(
+                    &fs_root,
+                    args.depth,
+                    args.width,
+                    symlink_count,
+                    symlink_mode,
+                );
+                println!(
+                    "modified {} files{}. verified {} paths, {} mismatches",
+                    modified_file_paths.len(),
+                    symlink_info,
+                    total,
+                    mismatched.len()
+                );
+                if args.print_missing_invalidations && !mismatched.is_empty() {
+                    let mut sorted = mismatched;
+                    sorted.sort_unstable();
+                    for path in &sorted {
+                        println!("  mismatch {path:?}");
+                    }
+                }
+            } else {
                 let mut invalidations = invalidations.0.lock().unwrap();
-                let symlink_info = if args.symlinks.is_some() {
-                    " and symlinks"
-                } else {
-                    ""
-                };
                 println!(
                     "modified {} files{}. found {} invalidations",
                     modified_file_paths.len(),
@@ -267,48 +346,188 @@ async fn read_link(
     Ok(())
 }
 
+#[turbo_tasks::function]
+async fn write_path(
+    invalidations: TransientInstance<PathInvalidations>,
+    path: FileSystemPath,
+) -> anyhow::Result<()> {
+    let path_str = path.path.clone();
+    invalidations.0.lock().unwrap().insert(path_str);
+    let content = FileContent::Content(File::from(FILE_SENTINEL_CONTENT));
+    let _ = path.write(content.cell()).await?;
+    Ok(())
+}
+
+#[turbo_tasks::function]
+async fn write_link(
+    invalidations: TransientInstance<PathInvalidations>,
+    path: FileSystemPath,
+    target: RcStr,
+    is_directory: bool,
+) -> anyhow::Result<()> {
+    let path_str = path.path.clone();
+    invalidations.0.lock().unwrap().insert(path_str);
+    let link_type = if is_directory {
+        LinkType::DIRECTORY
+    } else {
+        LinkType::empty()
+    };
+    let link_content = LinkContent::Link { target, link_type };
+    let _ = path
+        .fs()
+        .write_link(path.clone(), link_content.cell())
+        .await?;
+    Ok(())
+}
+
 #[turbo_tasks::function(operation)]
-async fn read_all_paths_operation(
+async fn read_or_write_all_paths_operation(
     invalidations: TransientInstance<PathInvalidations>,
     root: FileSystemPath,
     depth: usize,
     width: usize,
     symlink_count: u32,
+    symlink_is_directory: Option<bool>,
+    write: bool,
 ) -> anyhow::Result<()> {
-    async fn read_all_paths_inner(
+    async fn process_paths_inner(
         invalidations: TransientInstance<PathInvalidations>,
         parent: FileSystemPath,
         depth: usize,
         width: usize,
+        write: bool,
     ) -> anyhow::Result<()> {
         for child_id in 0..width {
             let child_name = child_id.to_string();
             let child_path = parent.join(&child_name)?;
             if depth == 1 {
-                read_path(invalidations.clone(), child_path).await?;
+                if write {
+                    write_path(invalidations.clone(), child_path).await?;
+                } else {
+                    read_path(invalidations.clone(), child_path).await?;
+                }
             } else {
-                Box::pin(read_all_paths_inner(
+                Box::pin(process_paths_inner(
                     invalidations.clone(),
                     child_path,
                     depth - 1,
                     width,
+                    write,
                 ))
                 .await?;
             }
         }
         Ok(())
     }
-    read_all_paths_inner(invalidations.clone(), root.clone(), depth, width).await?;
-
-    let symlinks_dir = root.join("_symlinks")?;
-    for i in 0..symlink_count {
-        let symlink_path = symlinks_dir.join(&i.to_string())?;
-        read_link(invalidations.clone(), symlink_path).await?;
+    process_paths_inner(invalidations.clone(), root.clone(), depth, width, write).await?;
+
+    if symlink_count > 0 {
+        let symlinks_dir = root.join("_symlinks")?;
+        for i in 0..symlink_count {
+            let symlink_path = symlinks_dir.join(&i.to_string())?;
+            if write {
+                write_link(
+                    invalidations.clone(),
+                    symlink_path,
+                    RcStr::from(SYMLINK_SENTINEL_TARGET),
+                    symlink_is_directory.unwrap_or(false),
+                )
+                .await?;
+            } else {
+                read_link(invalidations.clone(), symlink_path).await?;
+            }
+        }
     }
 
     Ok(())
 }
 
+/// Verifies that all files and symlinks have the expected sentinel content. Returns (total_checked,
+/// mismatched_paths).
+///
+/// We use this when using `--track-writes`/`track_writes`. We can't use the same trick that reads
+/// do, because `write`/`write_link` will never invalidate their caller (their return value is
+/// `Vc<()>`).
+fn verify_written_files(
+    fs_root: &Path,
+    depth: usize,
+    width: usize,
+    symlink_count: u32,
+    symlink_mode: Option<SymlinkMode>,
+) -> (usize, Vec<PathBuf>) {
+    fn check_files_inner(
+        parent: &Path,
+        depth: usize,
+        width: usize,
+        total: &mut usize,
+        mismatched: &mut Vec<PathBuf>,
+    ) {
+        for child_id in 0..width {
+            let child_path = parent.join(child_id.to_string());
+            if depth == 1 {
+                *total += 1;
+                match std::fs::read(&child_path) {
+                    Ok(content) if content == FILE_SENTINEL_CONTENT => {}
+                    _ => mismatched.push(child_path),
+                }
+            } else {
+                check_files_inner(&child_path, depth - 1, width, total, mismatched);
+            }
+        }
+    }
+
+    let mut total = 0;
+    let mut mismatched = Vec::new();
+
+    check_files_inner(fs_root, depth, width, &mut total, &mut mismatched);
+
+    if symlink_count > 0 {
+        let symlinks_dir = fs_root.join("_symlinks");
+
+        // Compute expected target based on mode. On Windows, junctions are stored with absolute
+        // paths by DiskFileSystem::write_link. We also need to canonicalize because read_link
+        // returns paths with the \\?\ extended-length prefix.
+        #[cfg(windows)]
+        let expected_target_canonicalized: Option<PathBuf> = match symlink_mode {
+            Some(SymlinkMode::Junction) => {
+                // Absolute path: fs_root/_symlinks/../0 resolves to fs_root/0
+                // Canonicalize to get the \\?\ prefixed form that read_link returns
+                std::fs::canonicalize(fs_root.join("0")).ok()
+            }
+            _ => None,
+        };
+
+        for i in 0..symlink_count {
+            total += 1;
+            let symlink_path = symlinks_dir.join(i.to_string());
+            let matches = match std::fs::read_link(&symlink_path) {
+                Ok(target) => {
+                    #[cfg(windows)]
+                    {
+                        if let Some(ref expected) = expected_target_canonicalized {
+                            // Canonicalize the target we read back for consistent comparison
+                            std::fs::canonicalize(&target).ok().as_ref() == Some(expected)
+                        } else {
+                            target == Path::new(SYMLINK_SENTINEL_TARGET)
+                        }
+                    }
+                    #[cfg(not(windows))]
+                    {
+                        let _ = symlink_mode;
+                        target == Path::new(SYMLINK_SENTINEL_TARGET)
+                    }
+                }
+                Err(_) => false,
+            };
+            if !matches {
+                mismatched.push(symlink_path);
+            }
+        }
+    }
+
+    (total, mismatched)
+}
+
 fn create_directory_tree(
     modified_file_paths: &mut FxHashSet<PathBuf>,
     parent: &Path,

From ddd02ab95d375db08627f023df7067fc607636c2 Mon Sep 17 00:00:00 2001
From: Benjamin Woodruff <benjamin.woodruff@vercel.com>
Date: Wed, 21 Jan 2026 10:41:29 -0800
Subject: [PATCH 8/8] Turbopack: Move fuzzer for fs watcher into a separate
 file/module (#88666)

This PR just moves things around for #88667.

I don't care about the code quality here, so this was LLM-generated with very lightweight review.
---
 .../crates/turbo-tasks-fuzz/src/fs_watcher.rs | 647 +++++++++++++++++
 turbopack/crates/turbo-tasks-fuzz/src/main.rs | 650 +-----------------
 2 files changed, 651 insertions(+), 646 deletions(-)
 create mode 100644 turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs

diff --git a/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs b/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs
new file mode 100644
index 00000000000000..3209f44a244d19
--- /dev/null
+++ b/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs
@@ -0,0 +1,647 @@
+#![allow(clippy::needless_return)]
+
+use std::{
+    fs::OpenOptions,
+    io::Write,
+    iter,
+    path::{Path, PathBuf},
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+
+use clap::{Args, ValueEnum};
+use rand::{Rng, RngCore, SeedableRng};
+use rustc_hash::FxHashSet;
+use tokio::time::sleep;
+use turbo_rcstr::{RcStr, rcstr};
+use turbo_tasks::{
+    NonLocalValue, ResolvedVc, TransientInstance, Vc, apply_effects, trace::TraceRawVcs,
+};
+use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};
+use turbo_tasks_fs::{
+    DiskFileSystem, File, FileContent, FileSystem, FileSystemPath, LinkContent, LinkType,
+};
+
+// `read_or_write_all_paths_operation` always writes the sentinel values to files/symlinks. We can
+// check for these sentinel values to see if `write`/`write_link` was re-run.
+const FILE_SENTINEL_CONTENT: &[u8] = b"sentinel_value";
+const SYMLINK_SENTINEL_TARGET: &str = "../0";
+
+#[derive(Args)]
+pub struct FsWatcher {
+    #[arg(long)]
+    fs_root: PathBuf,
+    #[arg(long, default_value_t = 4)]
+    depth: usize,
+    #[arg(long, default_value_t = 6)]
+    width: usize,
+    #[arg(long, default_value_t = 100)]
+    notify_timeout_ms: u64,
+    #[arg(long, default_value_t = 200)]
+    file_modifications: u32,
+    #[arg(long, default_value_t = 2)]
+    directory_modifications: u32,
+    #[arg(long)]
+    print_missing_invalidations: bool,
+    /// Call `start_watching` after the initial read of files instead of before (the default).
+    #[arg(long)]
+    start_watching_late: bool,
+    /// Enable symlink testing. The mode controls what kind of targets the symlinks point to.
+    #[arg(long, value_enum)]
+    symlinks: Option<SymlinkMode>,
+    /// Total number of symlinks to create.
+    #[arg(long, default_value_t = 80, requires = "symlinks")]
+    symlink_count: u32,
+    /// Number of symlink modifications per iteration (only used when --symlinks is set).
+    #[arg(long, default_value_t = 20, requires = "symlinks")]
+    symlink_modifications: u32,
+    /// Track file writes instead of reads. When enabled, the fuzzer writes files via
+    /// turbo-tasks and verifies that external modifications trigger invalidations.
+    #[arg(long)]
+    track_writes: bool,
+}
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum SymlinkMode {
+    /// Test file symlinks
+    #[cfg_attr(windows, doc = "(requires developer mode or admin)")]
+    File,
+    /// Test directory symlinks
+    #[cfg_attr(windows, doc = "(requires developer mode or admin)")]
+    Directory,
+    /// Test junction points (Windows-only)
+    #[cfg(windows)]
+    Junction,
+}
+
+impl SymlinkMode {
+    fn to_link_type(self) -> LinkType {
+        match self {
+            SymlinkMode::File => LinkType::empty(),
+            SymlinkMode::Directory => LinkType::DIRECTORY,
+            #[cfg(windows)]
+            SymlinkMode::Junction => LinkType::DIRECTORY,
+        }
+    }
+}
+
+#[derive(Default, NonLocalValue, TraceRawVcs)]
+struct PathInvalidations(#[turbo_tasks(trace_ignore)] Arc<Mutex<FxHashSet<RcStr>>>);
+
+pub async fn run(args: FsWatcher) -> anyhow::Result<()> {
+    std::fs::create_dir(&args.fs_root)?;
+    let fs_root = args.fs_root.canonicalize()?;
+    let _guard = FsCleanup {
+        path: &fs_root.clone(),
+    };
+
+    let tt = turbo_tasks::TurboTasks::new(TurboTasksBackend::new(
+        BackendOptions::default(),
+        noop_backing_storage(),
+    ));
+
+    tt.run_once(async move {
+        let invalidations = TransientInstance::new(PathInvalidations::default());
+        let fs_root_rcstr = RcStr::from(fs_root.to_str().unwrap());
+        let project_fs = disk_file_system_operation(fs_root_rcstr.clone())
+            .resolve_strongly_consistent()
+            .await?;
+        let project_root = disk_file_system_root_operation(project_fs)
+            .resolve_strongly_consistent()
+            .await?
+            .owned()
+            .await?;
+
+        create_directory_tree(&mut FxHashSet::default(), &fs_root, args.depth, args.width)?;
+
+        let mut symlink_targets = if let Some(mode) = args.symlinks {
+            create_initial_symlinks(&fs_root, mode, args.symlink_count, args.depth)?
+        } else {
+            Vec::new()
+        };
+
+        if !args.start_watching_late {
+            project_fs.await?.start_watching(None).await?;
+        }
+
+        let symlink_count = if args.symlinks.is_some() {
+            args.symlink_count
+        } else {
+            0
+        };
+        let track_writes = args.track_writes;
+        let symlink_mode = args.symlinks;
+        let symlink_is_directory =
+            symlink_mode.map(|m| m.to_link_type().contains(LinkType::DIRECTORY));
+
+        let initial_op = read_or_write_all_paths_operation(
+            invalidations.clone(),
+            project_root.clone(),
+            args.depth,
+            args.width,
+            symlink_count,
+            symlink_is_directory,
+            track_writes,
+        );
+        initial_op.read_strongly_consistent().await?;
+        if track_writes {
+            apply_effects(initial_op).await?;
+            let (total, mismatched) = verify_written_files(
+                &fs_root,
+                args.depth,
+                args.width,
+                symlink_count,
+                symlink_mode,
+            );
+            println!("wrote all {} paths, {} mismatches", total, mismatched.len());
+            if args.print_missing_invalidations && !mismatched.is_empty() {
+                for path in &mismatched {
+                    println!("  mismatch {path:?}");
+                }
+            }
+        } else {
+            let invalidations = invalidations.0.lock().unwrap();
+            println!("read all {} files", invalidations.len());
+        }
+        invalidations.0.lock().unwrap().clear();
+
+        if args.start_watching_late {
+            project_fs.await?.start_watching(None).await?;
+        }
+
+        let mut rand_buf = [0; 16];
+        let mut rng = rand::rngs::SmallRng::from_rng(&mut rand::rng());
+        loop {
+            let mut modified_file_paths = FxHashSet::default();
+            for _ in 0..args.file_modifications {
+                let path = fs_root.join(pick_random_file(args.depth, args.width));
+                let mut f = OpenOptions::new().write(true).truncate(true).open(&path)?;
+                rng.fill_bytes(&mut rand_buf);
+                f.write_all(&rand_buf)?;
+                f.flush()?;
+                modified_file_paths.insert(path);
+            }
+            for _ in 0..args.directory_modifications {
+                let dir = pick_random_directory(args.depth, args.width);
+                let path = fs_root.join(dir.path);
+                std::fs::remove_dir_all(&path)?;
+                std::fs::create_dir(&path)?;
+                create_directory_tree(
+                    &mut modified_file_paths,
+                    &path,
+                    args.depth - dir.depth,
+                    args.width,
+                )?;
+            }
+
+            if let Some(mode) = args.symlinks
+                && !symlink_targets.is_empty()
+            {
+                for _ in 0..args.symlink_modifications {
+                    let symlink_idx = rng.random_range(0..symlink_targets.len());
+                    let old_target = &symlink_targets[symlink_idx];
+
+                    let new_target_relative = pick_random_link_target(args.depth, args.width, mode);
+
+                    if new_target_relative != *old_target {
+                        let symlink_path = fs_root.join("_symlinks").join(symlink_idx.to_string());
+                        let relative_target = Path::new("..").join(&new_target_relative);
+
+                        remove_symlink(&symlink_path, mode)?;
+                        create_symlink(&symlink_path, &relative_target, mode)?;
+
+                        modified_file_paths.insert(symlink_path);
+                        symlink_targets[symlink_idx] = new_target_relative;
+                    }
+                }
+            }
+
+            // there's no way to know when we've received all the pending events from the operating
+            // system, so just sleep and pray
+            sleep(Duration::from_millis(args.notify_timeout_ms)).await;
+            let read_or_write_op = read_or_write_all_paths_operation(
+                invalidations.clone(),
+                project_root.clone(),
+                args.depth,
+                args.width,
+                symlink_count,
+                symlink_is_directory,
+                track_writes,
+            );
+            read_or_write_op.read_strongly_consistent().await?;
+            let symlink_info = if args.symlinks.is_some() {
+                " and symlinks"
+            } else {
+                ""
+            };
+            if track_writes {
+                apply_effects(read_or_write_op).await?;
+                let (total, mismatched) = verify_written_files(
+                    &fs_root,
+                    args.depth,
+                    args.width,
+                    symlink_count,
+                    symlink_mode,
+                );
+                println!(
+                    "modified {} files{}. verified {} paths, {} mismatches",
+                    modified_file_paths.len(),
+                    symlink_info,
+                    total,
+                    mismatched.len()
+                );
+                if args.print_missing_invalidations && !mismatched.is_empty() {
+                    let mut sorted = mismatched;
+                    sorted.sort_unstable();
+                    for path in &sorted {
+                        println!("  mismatch {path:?}");
+                    }
+                }
+            } else {
+                let mut invalidations = invalidations.0.lock().unwrap();
+                println!(
+                    "modified {} files{}. found {} invalidations",
+                    modified_file_paths.len(),
+                    symlink_info,
+                    invalidations.len()
+                );
+                if args.print_missing_invalidations {
+                    let absolute_path_invalidations = invalidations
+                        .iter()
+                        .map(|relative_path| fs_root.join(relative_path))
+                        .collect::<FxHashSet<PathBuf>>();
+                    let mut missing = modified_file_paths
+                        .difference(&absolute_path_invalidations)
+                        .collect::<Vec<_>>();
+                    missing.sort_unstable();
+                    for path in &missing {
+                        println!("  missing {path:?}");
+                    }
+                }
+                invalidations.clear();
+            }
+        }
+    })
+    .await
+}
+
+#[turbo_tasks::function(operation)]
+fn disk_file_system_operation(fs_root: RcStr) -> Vc<DiskFileSystem> {
+    DiskFileSystem::new(rcstr!("project"), fs_root)
+}
+
+#[turbo_tasks::function(operation)]
+fn disk_file_system_root_operation(fs: ResolvedVc<DiskFileSystem>) -> Vc<FileSystemPath> {
+    fs.root()
+}
+
+#[turbo_tasks::function]
+async fn read_path(
+    invalidations: TransientInstance<PathInvalidations>,
+    path: FileSystemPath,
+) -> anyhow::Result<()> {
+    let path_str = path.path.clone();
+    invalidations.0.lock().unwrap().insert(path_str);
+    let _ = path.read().await?;
+    Ok(())
+}
+
+#[turbo_tasks::function]
+async fn read_link(
+    invalidations: TransientInstance<PathInvalidations>,
+    path: FileSystemPath,
+) -> anyhow::Result<()> {
+    let path_str = path.path.clone();
+    invalidations.0.lock().unwrap().insert(path_str);
+    let _ = path.read_link().await?;
+    Ok(())
+}
+
+#[turbo_tasks::function]
+async fn write_path(
+    invalidations: TransientInstance<PathInvalidations>,
+    path: FileSystemPath,
+) -> anyhow::Result<()> {
+    let path_str = path.path.clone();
+    invalidations.0.lock().unwrap().insert(path_str);
+    let content = FileContent::Content(File::from(FILE_SENTINEL_CONTENT));
+    let _ = path.write(content.cell()).await?;
+    Ok(())
+}
+
+#[turbo_tasks::function]
+async fn write_link(
+    invalidations: TransientInstance<PathInvalidations>,
+    path: FileSystemPath,
+    target: RcStr,
+    is_directory: bool,
+) -> anyhow::Result<()> {
+    let path_str = path.path.clone();
+    invalidations.0.lock().unwrap().insert(path_str);
+    let link_type = if is_directory {
+        LinkType::DIRECTORY
+    } else {
+        LinkType::empty()
+    };
+    let link_content = LinkContent::Link { target, link_type };
+    let _ = path
+        .fs()
+        .write_link(path.clone(), link_content.cell())
+        .await?;
+    Ok(())
+}
+
+#[turbo_tasks::function(operation)]
+async fn read_or_write_all_paths_operation(
+    invalidations: TransientInstance<PathInvalidations>,
+    root: FileSystemPath,
+    depth: usize,
+    width: usize,
+    symlink_count: u32,
+    symlink_is_directory: Option<bool>,
+    write: bool,
+) -> anyhow::Result<()> {
+    async fn process_paths_inner(
+        invalidations: TransientInstance<PathInvalidations>,
+        parent: FileSystemPath,
+        depth: usize,
+        width: usize,
+        write: bool,
+    ) -> anyhow::Result<()> {
+        for child_id in 0..width {
+            let child_name = child_id.to_string();
+            let child_path = parent.join(&child_name)?;
+            if depth == 1 {
+                if write {
+                    write_path(invalidations.clone(), child_path).await?;
+                } else {
+                    read_path(invalidations.clone(), child_path).await?;
+                }
+            } else {
+                Box::pin(process_paths_inner(
+                    invalidations.clone(),
+                    child_path,
+                    depth - 1,
+                    width,
+                    write,
+                ))
+                .await?;
+            }
+        }
+        Ok(())
+    }
+    process_paths_inner(invalidations.clone(), root.clone(), depth, width, write).await?;
+
+    if symlink_count > 0 {
+        let symlinks_dir = root.join("_symlinks")?;
+        for i in 0..symlink_count {
+            let symlink_path = symlinks_dir.join(&i.to_string())?;
+            if write {
+                write_link(
+                    invalidations.clone(),
+                    symlink_path,
+                    RcStr::from(SYMLINK_SENTINEL_TARGET),
+                    symlink_is_directory.unwrap_or(false),
+                )
+                .await?;
+            } else {
+                read_link(invalidations.clone(), symlink_path).await?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Verifies that all files and symlinks have the expected sentinel content. Returns (total_checked,
+/// mismatched_paths).
+///
+/// We use this when using `--track-writes`/`track_writes`. We can't use the same trick that reads
+/// do, because `write`/`write_link` will never invalidate their caller (their return value is
+/// `Vc<()>`).
+fn verify_written_files(
+    fs_root: &Path,
+    depth: usize,
+    width: usize,
+    symlink_count: u32,
+    symlink_mode: Option<SymlinkMode>,
+) -> (usize, Vec<PathBuf>) {
+    fn check_files_inner(
+        parent: &Path,
+        depth: usize,
+        width: usize,
+        total: &mut usize,
+        mismatched: &mut Vec<PathBuf>,
+    ) {
+        for child_id in 0..width {
+            let child_path = parent.join(child_id.to_string());
+            if depth == 1 {
+                *total += 1;
+                match std::fs::read(&child_path) {
+                    Ok(content) if content == FILE_SENTINEL_CONTENT => {}
+                    _ => mismatched.push(child_path),
+                }
+            } else {
+                check_files_inner(&child_path, depth - 1, width, total, mismatched);
+            }
+        }
+    }
+
+    let mut total = 0;
+    let mut mismatched = Vec::new();
+
+    check_files_inner(fs_root, depth, width, &mut total, &mut mismatched);
+
+    if symlink_count > 0 {
+        let symlinks_dir = fs_root.join("_symlinks");
+
+        // Compute expected target based on mode. On Windows, junctions are stored with absolute
+        // paths by DiskFileSystem::write_link. We also need to canonicalize because read_link
+        // returns paths with the \\?\ extended-length prefix.
+        #[cfg(windows)]
+        let expected_target_canonicalized: Option<PathBuf> = match symlink_mode {
+            Some(SymlinkMode::Junction) => {
+                // Absolute path: fs_root/_symlinks/../0 resolves to fs_root/0
+                // Canonicalize to get the \\?\ prefixed form that read_link returns
+                std::fs::canonicalize(fs_root.join("0")).ok()
+            }
+            _ => None,
+        };
+
+        for i in 0..symlink_count {
+            total += 1;
+            let symlink_path = symlinks_dir.join(i.to_string());
+            let matches = match std::fs::read_link(&symlink_path) {
+                Ok(target) => {
+                    #[cfg(windows)]
+                    {
+                        if let Some(ref expected) = expected_target_canonicalized {
+                            // Canonicalize the target we read back for consistent comparison
+                            std::fs::canonicalize(&target).ok().as_ref() == Some(expected)
+                        } else {
+                            target == Path::new(SYMLINK_SENTINEL_TARGET)
+                        }
+                    }
+                    #[cfg(not(windows))]
+                    {
+                        let _ = symlink_mode;
+                        target == Path::new(SYMLINK_SENTINEL_TARGET)
+                    }
+                }
+                Err(_) => false,
+            };
+            if !matches {
+                mismatched.push(symlink_path);
+            }
+        }
+    }
+
+    (total, mismatched)
+}
+
+fn create_directory_tree(
+    modified_file_paths: &mut FxHashSet<PathBuf>,
+    parent: &Path,
+    depth: usize,
+    width: usize,
+) -> anyhow::Result<()> {
+    let mut rng = rand::rng();
+    let mut rand_buf = [0; 16];
+    for child_id in 0..width {
+        let child_name = child_id.to_string();
+        let child_path = parent.join(&child_name);
+        if depth == 1 {
+            let mut f = std::fs::File::create(&child_path)?;
+            rng.fill_bytes(&mut rand_buf);
+            f.write_all(&rand_buf)?;
+            f.flush()?;
+            modified_file_paths.insert(child_path);
+        } else {
+            std::fs::create_dir(&child_path)?;
+            create_directory_tree(modified_file_paths, &child_path, depth - 1, width)?;
+        }
+    }
+    Ok(())
+}
+
+fn create_initial_symlinks(
+    fs_root: &Path,
+    symlink_mode: SymlinkMode,
+    symlink_count: u32,
+    depth: usize,
+) -> anyhow::Result<Vec<PathBuf>> {
+    // Use a dedicated "symlinks" directory to avoid conflicts
+    let symlinks_dir = fs_root.join("_symlinks");
+    std::fs::create_dir_all(&symlinks_dir)?;
+
+    let initial_target_relative = match symlink_mode {
+        SymlinkMode::File => {
+            // Point to a file at depth: 0/0/0/.../0
+            let mut path = PathBuf::new();
+            for _ in 0..depth {
+                path.push("0");
+            }
+            path
+        }
+        SymlinkMode::Directory => PathBuf::from("0"),
+        #[cfg(windows)]
+        SymlinkMode::Junction => PathBuf::from("0"),
+    };
+
+    let relative_target = Path::new("..").join(&initial_target_relative);
+
+    let mut symlink_targets = Vec::new();
+    for i in 0..symlink_count {
+        let symlink_path = symlinks_dir.join(i.to_string());
+        create_symlink(&symlink_path, &relative_target, symlink_mode)?;
+        symlink_targets.push(initial_target_relative.clone());
+    }
+
+    Ok(symlink_targets)
+}
+
+fn create_symlink(link_path: &Path, target: &Path, mode: SymlinkMode) -> anyhow::Result<()> {
+    #[cfg(unix)]
+    {
+        let _ = mode;
+        std::os::unix::fs::symlink(target, link_path)?;
+    }
+    #[cfg(windows)]
+    {
+        match mode {
+            SymlinkMode::File => {
+                std::os::windows::fs::symlink_file(target, link_path)?;
+            }
+            SymlinkMode::Directory => {
+                std::os::windows::fs::symlink_dir(target, link_path)?;
+            }
+            SymlinkMode::Junction => {
+                // Junction points require absolute paths
+                let absolute_target = link_path.parent().unwrap_or(link_path).join(target);
+                std::os::windows::fs::junction_point(&absolute_target, link_path)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn remove_symlink(link_path: &Path, mode: SymlinkMode) -> anyhow::Result<()> {
+    #[cfg(unix)]
+    {
+        let _ = mode;
+        std::fs::remove_file(link_path)?;
+    }
+    #[cfg(windows)]
+    {
+        match mode {
+            SymlinkMode::File | SymlinkMode::Directory => {
+                std::fs::remove_file(link_path)?;
+            }
+            SymlinkMode::Junction => {
+                std::fs::remove_dir(link_path)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn pick_random_file(depth: usize, width: usize) -> PathBuf {
+    let mut rng = rand::rng();
+    iter::repeat_with(|| rng.random_range(0..width).to_string())
+        .take(depth)
+        .collect()
+}
+
+struct RandomDirectory {
+    depth: usize,
+    path: PathBuf,
+}
+
+fn pick_random_directory(max_depth: usize, width: usize) -> RandomDirectory {
+    let mut rng = rand::rng();
+    // never use a depth of 0 because that would be the root directory
+    let depth = rng.random_range(1..(max_depth - 1));
+    let path = iter::repeat_with(|| rng.random_range(0..width).to_string())
+        .take(depth)
+        .collect();
+    RandomDirectory { depth, path }
+}
+
+fn pick_random_link_target(depth: usize, width: usize, mode: SymlinkMode) -> PathBuf {
+    match mode {
+        SymlinkMode::File => pick_random_file(depth, width),
+        SymlinkMode::Directory => pick_random_directory(depth, width).path,
+        #[cfg(windows)]
+        SymlinkMode::Junction => pick_random_directory(depth, width).path,
+    }
+}
+
+struct FsCleanup<'a> {
+    path: &'a Path,
+}
+
+impl Drop for FsCleanup<'_> {
+    fn drop(&mut self) {
+        std::fs::remove_dir_all(self.path).unwrap();
+    }
+}
diff --git a/turbopack/crates/turbo-tasks-fuzz/src/main.rs b/turbopack/crates/turbo-tasks-fuzz/src/main.rs
index dcaa265a1d2bad..d82325d40b0936 100644
--- a/turbopack/crates/turbo-tasks-fuzz/src/main.rs
+++ b/turbopack/crates/turbo-tasks-fuzz/src/main.rs
@@ -1,31 +1,8 @@
 #![cfg_attr(windows, feature(junction_point))]
 
-use std::{
-    fs::OpenOptions,
-    io::Write,
-    iter,
-    path::{Path, PathBuf},
-    sync::{Arc, Mutex},
-    time::Duration,
-};
+mod fs_watcher;
 
-use clap::{Args, Parser, Subcommand, ValueEnum};
-use rand::{Rng, RngCore, SeedableRng};
-use rustc_hash::FxHashSet;
-use tokio::time::sleep;
-use turbo_rcstr::{RcStr, rcstr};
-use turbo_tasks::{
-    NonLocalValue, ResolvedVc, TransientInstance, Vc, apply_effects, trace::TraceRawVcs,
-};
-use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};
-use turbo_tasks_fs::{
-    DiskFileSystem, File, FileContent, FileSystem, FileSystemPath, LinkContent, LinkType,
-};
-
-// `read_or_write_all_paths_operation` always writes the sentinel values to files/symlinks. We can
-// check for these sentinel values to see if `write`/`write_link` was re-run.
-const FILE_SENTINEL_CONTENT: &[u8] = b"sentinel_value";
-const SYMLINK_SENTINEL_TARGET: &str = "../0";
+use clap::{Parser, Subcommand};
 
 /// A collection of fuzzers for `turbo-tasks`. These are not test cases as they're slow and (in many
 /// cases) non-deterministic.
@@ -44,65 +21,7 @@ struct Cli {
 #[derive(Subcommand)]
 enum Commands {
     /// Continuously fuzzes the filesystem watcher until ctrl+c'd.
-    FsWatcher(FsWatcher),
-}
-
-#[derive(Args)]
-struct FsWatcher {
-    #[arg(long)]
-    fs_root: PathBuf,
-    #[arg(long, default_value_t = 4)]
-    depth: usize,
-    #[arg(long, default_value_t = 6)]
-    width: usize,
-    #[arg(long, default_value_t = 100)]
-    notify_timeout_ms: u64,
-    #[arg(long, default_value_t = 200)]
-    file_modifications: u32,
-    #[arg(long, default_value_t = 2)]
-    directory_modifications: u32,
-    #[arg(long)]
-    print_missing_invalidations: bool,
-    /// Call `start_watching` after the initial read of files instead of before (the default).
-    #[arg(long)]
-    start_watching_late: bool,
-    /// Enable symlink testing. The mode controls what kind of targets the symlinks point to.
-    #[arg(long, value_enum)]
-    symlinks: Option<SymlinkMode>,
-    /// Total number of symlinks to create.
-    #[arg(long, default_value_t = 80, requires = "symlinks")]
-    symlink_count: u32,
-    /// Number of symlink modifications per iteration (only used when --symlinks is set).
-    #[arg(long, default_value_t = 20, requires = "symlinks")]
-    symlink_modifications: u32,
-    /// Track file writes instead of reads. When enabled, the fuzzer writes files via
-    /// turbo-tasks and verifies that external modifications trigger invalidations.
-    #[arg(long)]
-    track_writes: bool,
-}
-
-#[derive(Clone, Copy, Debug, ValueEnum)]
-enum SymlinkMode {
-    /// Test file symlinks
-    #[cfg_attr(windows, doc = "(requires developer mode or admin)")]
-    File,
-    /// Test directory symlinks
-    #[cfg_attr(windows, doc = "(requires developer mode or admin)")]
-    Directory,
-    /// Test junction points (Windows-only)
-    #[cfg(windows)]
-    Junction,
-}
-
-impl SymlinkMode {
-    fn to_link_type(self) -> LinkType {
-        match self {
-            SymlinkMode::File => LinkType::empty(),
-            SymlinkMode::Directory => LinkType::DIRECTORY,
-            #[cfg(windows)]
-            SymlinkMode::Junction => LinkType::DIRECTORY,
-        }
-    }
+    FsWatcher(fs_watcher::FsWatcher),
 }
 
 #[tokio::main]
@@ -110,567 +29,6 @@ async fn main() -> anyhow::Result<()> {
     let cli = Cli::parse();
 
     match cli.command {
-        Commands::FsWatcher(args) => fuzz_fs_watcher(args).await,
-    }
-}
-
-#[derive(Default, NonLocalValue, TraceRawVcs)]
-struct PathInvalidations(#[turbo_tasks(trace_ignore)] Arc<Mutex<FxHashSet<RcStr>>>);
-
-async fn fuzz_fs_watcher(args: FsWatcher) -> anyhow::Result<()> {
-    std::fs::create_dir(&args.fs_root)?;
-    let fs_root = args.fs_root.canonicalize()?;
-    let _guard = FsCleanup {
-        path: &fs_root.clone(),
-    };
-
-    let tt = turbo_tasks::TurboTasks::new(TurboTasksBackend::new(
-        BackendOptions::default(),
-        noop_backing_storage(),
-    ));
-
-    tt.run_once(async move {
-        let invalidations = TransientInstance::new(PathInvalidations::default());
-        let fs_root_rcstr = RcStr::from(fs_root.to_str().unwrap());
-        let project_fs = disk_file_system_operation(fs_root_rcstr.clone())
-            .resolve_strongly_consistent()
-            .await?;
-        let project_root = disk_file_system_root_operation(project_fs)
-            .resolve_strongly_consistent()
-            .await?
-            .owned()
-            .await?;
-
-        create_directory_tree(&mut FxHashSet::default(), &fs_root, args.depth, args.width)?;
-
-        let mut symlink_targets = if let Some(mode) = args.symlinks {
-            create_initial_symlinks(&fs_root, mode, args.symlink_count, args.depth)?
-        } else {
-            Vec::new()
-        };
-
-        if !args.start_watching_late {
-            project_fs.await?.start_watching(None).await?;
-        }
-
-        let symlink_count = if args.symlinks.is_some() {
-            args.symlink_count
-        } else {
-            0
-        };
-        let track_writes = args.track_writes;
-        let symlink_mode = args.symlinks;
-        let symlink_is_directory =
-            symlink_mode.map(|m| m.to_link_type().contains(LinkType::DIRECTORY));
-
-        let initial_op = read_or_write_all_paths_operation(
-            invalidations.clone(),
-            project_root.clone(),
-            args.depth,
-            args.width,
-            symlink_count,
-            symlink_is_directory,
-            track_writes,
-        );
-        initial_op.read_strongly_consistent().await?;
-        if track_writes {
-            apply_effects(initial_op).await?;
-            let (total, mismatched) = verify_written_files(
-                &fs_root,
-                args.depth,
-                args.width,
-                symlink_count,
-                symlink_mode,
-            );
-            println!("wrote all {} paths, {} mismatches", total, mismatched.len());
-            if args.print_missing_invalidations && !mismatched.is_empty() {
-                for path in &mismatched {
-                    println!("  mismatch {path:?}");
-                }
-            }
-        } else {
-            let invalidations = invalidations.0.lock().unwrap();
-            println!("read all {} files", invalidations.len());
-        }
-        invalidations.0.lock().unwrap().clear();
-
-        if args.start_watching_late {
-            project_fs.await?.start_watching(None).await?;
-        }
-
-        let mut rand_buf = [0; 16];
-        let mut rng = rand::rngs::SmallRng::from_rng(&mut rand::rng());
-        loop {
-            let mut modified_file_paths = FxHashSet::default();
-            for _ in 0..args.file_modifications {
-                let path = fs_root.join(pick_random_file(args.depth, args.width));
-                let mut f = OpenOptions::new().write(true).truncate(true).open(&path)?;
-                rng.fill_bytes(&mut rand_buf);
-                f.write_all(&rand_buf)?;
-                f.flush()?;
-                modified_file_paths.insert(path);
-            }
-            for _ in 0..args.directory_modifications {
-                let dir = pick_random_directory(args.depth, args.width);
-                let path = fs_root.join(dir.path);
-                std::fs::remove_dir_all(&path)?;
-                std::fs::create_dir(&path)?;
-                create_directory_tree(
-                    &mut modified_file_paths,
-                    &path,
-                    args.depth - dir.depth,
-                    args.width,
-                )?;
-            }
-
-            if let Some(mode) = args.symlinks
-                && !symlink_targets.is_empty()
-            {
-                for _ in 0..args.symlink_modifications {
-                    let symlink_idx = rng.random_range(0..symlink_targets.len());
-                    let old_target = &symlink_targets[symlink_idx];
-
-                    let new_target_relative = pick_random_link_target(args.depth, args.width, mode);
-
-                    if new_target_relative != *old_target {
-                        let symlink_path = fs_root.join("_symlinks").join(symlink_idx.to_string());
-                        let relative_target = Path::new("..").join(&new_target_relative);
-
-                        remove_symlink(&symlink_path, mode)?;
-                        create_symlink(&symlink_path, &relative_target, mode)?;
-
-                        modified_file_paths.insert(symlink_path);
-                        symlink_targets[symlink_idx] = new_target_relative;
-                    }
-                }
-            }
-
-            // there's no way to know when we've received all the pending events from the operating
-            // system, so just sleep and pray
-            sleep(Duration::from_millis(args.notify_timeout_ms)).await;
-            let read_or_write_op = read_or_write_all_paths_operation(
-                invalidations.clone(),
-                project_root.clone(),
-                args.depth,
-                args.width,
-                symlink_count,
-                symlink_is_directory,
-                track_writes,
-            );
-            read_or_write_op.read_strongly_consistent().await?;
-            let symlink_info = if args.symlinks.is_some() {
-                " and symlinks"
-            } else {
-                ""
-            };
-            if track_writes {
-                apply_effects(read_or_write_op).await?;
-                let (total, mismatched) = verify_written_files(
-                    &fs_root,
-                    args.depth,
-                    args.width,
-                    symlink_count,
-                    symlink_mode,
-                );
-                println!(
-                    "modified {} files{}. verified {} paths, {} mismatches",
-                    modified_file_paths.len(),
-                    symlink_info,
-                    total,
-                    mismatched.len()
-                );
-                if args.print_missing_invalidations && !mismatched.is_empty() {
-                    let mut sorted = mismatched;
-                    sorted.sort_unstable();
-                    for path in &sorted {
-                        println!("  mismatch {path:?}");
-                    }
-                }
-            } else {
-                let mut invalidations = invalidations.0.lock().unwrap();
-                println!(
-                    "modified {} files{}. found {} invalidations",
-                    modified_file_paths.len(),
-                    symlink_info,
-                    invalidations.len()
-                );
-                if args.print_missing_invalidations {
-                    let absolute_path_invalidations = invalidations
-                        .iter()
-                        .map(|relative_path| fs_root.join(relative_path))
-                        .collect::<FxHashSet<PathBuf>>();
-                    let mut missing = modified_file_paths
-                        .difference(&absolute_path_invalidations)
-                        .collect::<Vec<_>>();
-                    missing.sort_unstable();
-                    for path in &missing {
-                        println!("  missing {path:?}");
-                    }
-                }
-                invalidations.clear();
-            }
-        }
-    })
-    .await
-}
-
-#[turbo_tasks::function(operation)]
-fn disk_file_system_operation(fs_root: RcStr) -> Vc<DiskFileSystem> {
-    DiskFileSystem::new(rcstr!("project"), fs_root)
-}
-
-#[turbo_tasks::function(operation)]
-fn disk_file_system_root_operation(fs: ResolvedVc<DiskFileSystem>) -> Vc<FileSystemPath> {
-    fs.root()
-}
-
-#[turbo_tasks::function]
-async fn read_path(
-    invalidations: TransientInstance<PathInvalidations>,
-    path: FileSystemPath,
-) -> anyhow::Result<()> {
-    let path_str = path.path.clone();
-    invalidations.0.lock().unwrap().insert(path_str);
-    let _ = path.read().await?;
-    Ok(())
-}
-
-#[turbo_tasks::function]
-async fn read_link(
-    invalidations: TransientInstance<PathInvalidations>,
-    path: FileSystemPath,
-) -> anyhow::Result<()> {
-    let path_str = path.path.clone();
-    invalidations.0.lock().unwrap().insert(path_str);
-    let _ = path.read_link().await?;
-    Ok(())
-}
-
-#[turbo_tasks::function]
-async fn write_path(
-    invalidations: TransientInstance<PathInvalidations>,
-    path: FileSystemPath,
-) -> anyhow::Result<()> {
-    let path_str = path.path.clone();
-    invalidations.0.lock().unwrap().insert(path_str);
-    let content = FileContent::Content(File::from(FILE_SENTINEL_CONTENT));
-    let _ = path.write(content.cell()).await?;
-    Ok(())
-}
-
-#[turbo_tasks::function]
-async fn write_link(
-    invalidations: TransientInstance<PathInvalidations>,
-    path: FileSystemPath,
-    target: RcStr,
-    is_directory: bool,
-) -> anyhow::Result<()> {
-    let path_str = path.path.clone();
-    invalidations.0.lock().unwrap().insert(path_str);
-    let link_type = if is_directory {
-        LinkType::DIRECTORY
-    } else {
-        LinkType::empty()
-    };
-    let link_content = LinkContent::Link { target, link_type };
-    let _ = path
-        .fs()
-        .write_link(path.clone(), link_content.cell())
-        .await?;
-    Ok(())
-}
-
-#[turbo_tasks::function(operation)]
-async fn read_or_write_all_paths_operation(
-    invalidations: TransientInstance<PathInvalidations>,
-    root: FileSystemPath,
-    depth: usize,
-    width: usize,
-    symlink_count: u32,
-    symlink_is_directory: Option<bool>,
-    write: bool,
-) -> anyhow::Result<()> {
-    async fn process_paths_inner(
-        invalidations: TransientInstance<PathInvalidations>,
-        parent: FileSystemPath,
-        depth: usize,
-        width: usize,
-        write: bool,
-    ) -> anyhow::Result<()> {
-        for child_id in 0..width {
-            let child_name = child_id.to_string();
-            let child_path = parent.join(&child_name)?;
-            if depth == 1 {
-                if write {
-                    write_path(invalidations.clone(), child_path).await?;
-                } else {
-                    read_path(invalidations.clone(), child_path).await?;
-                }
-            } else {
-                Box::pin(process_paths_inner(
-                    invalidations.clone(),
-                    child_path,
-                    depth - 1,
-                    width,
-                    write,
-                ))
-                .await?;
-            }
-        }
-        Ok(())
-    }
-    process_paths_inner(invalidations.clone(), root.clone(), depth, width, write).await?;
-
-    if symlink_count > 0 {
-        let symlinks_dir = root.join("_symlinks")?;
-        for i in 0..symlink_count {
-            let symlink_path = symlinks_dir.join(&i.to_string())?;
-            if write {
-                write_link(
-                    invalidations.clone(),
-                    symlink_path,
-                    RcStr::from(SYMLINK_SENTINEL_TARGET),
-                    symlink_is_directory.unwrap_or(false),
-                )
-                .await?;
-            } else {
-                read_link(invalidations.clone(), symlink_path).await?;
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// Verifies that all files and symlinks have the expected sentinel content. Returns (total_checked,
-/// mismatched_paths).
-///
-/// We use this when using `--track-writes`/`track_writes`. We can't use the same trick that reads
-/// do, because `write`/`write_link` will never invalidate their caller (their return value is
-/// `Vc<()>`).
-fn verify_written_files(
-    fs_root: &Path,
-    depth: usize,
-    width: usize,
-    symlink_count: u32,
-    symlink_mode: Option<SymlinkMode>,
-) -> (usize, Vec<PathBuf>) {
-    fn check_files_inner(
-        parent: &Path,
-        depth: usize,
-        width: usize,
-        total: &mut usize,
-        mismatched: &mut Vec<PathBuf>,
-    ) {
-        for child_id in 0..width {
-            let child_path = parent.join(child_id.to_string());
-            if depth == 1 {
-                *total += 1;
-                match std::fs::read(&child_path) {
-                    Ok(content) if content == FILE_SENTINEL_CONTENT => {}
-                    _ => mismatched.push(child_path),
-                }
-            } else {
-                check_files_inner(&child_path, depth - 1, width, total, mismatched);
-            }
-        }
-    }
-
-    let mut total = 0;
-    let mut mismatched = Vec::new();
-
-    check_files_inner(fs_root, depth, width, &mut total, &mut mismatched);
-
-    if symlink_count > 0 {
-        let symlinks_dir = fs_root.join("_symlinks");
-
-        // Compute expected target based on mode. On Windows, junctions are stored with absolute
-        // paths by DiskFileSystem::write_link. We also need to canonicalize because read_link
-        // returns paths with the \\?\ extended-length prefix.
-        #[cfg(windows)]
-        let expected_target_canonicalized: Option<PathBuf> = match symlink_mode {
-            Some(SymlinkMode::Junction) => {
-                // Absolute path: fs_root/_symlinks/../0 resolves to fs_root/0
-                // Canonicalize to get the \\?\ prefixed form that read_link returns
-                std::fs::canonicalize(fs_root.join("0")).ok()
-            }
-            _ => None,
-        };
-
-        for i in 0..symlink_count {
-            total += 1;
-            let symlink_path = symlinks_dir.join(i.to_string());
-            let matches = match std::fs::read_link(&symlink_path) {
-                Ok(target) => {
-                    #[cfg(windows)]
-                    {
-                        if let Some(ref expected) = expected_target_canonicalized {
-                            // Canonicalize the target we read back for consistent comparison
-                            std::fs::canonicalize(&target).ok().as_ref() == Some(expected)
-                        } else {
-                            target == Path::new(SYMLINK_SENTINEL_TARGET)
-                        }
-                    }
-                    #[cfg(not(windows))]
-                    {
-                        let _ = symlink_mode;
-                        target == Path::new(SYMLINK_SENTINEL_TARGET)
-                    }
-                }
-                Err(_) => false,
-            };
-            if !matches {
-                mismatched.push(symlink_path);
-            }
-        }
-    }
-
-    (total, mismatched)
-}
-
-fn create_directory_tree(
-    modified_file_paths: &mut FxHashSet<PathBuf>,
-    parent: &Path,
-    depth: usize,
-    width: usize,
-) -> anyhow::Result<()> {
-    let mut rng = rand::rng();
-    let mut rand_buf = [0; 16];
-    for child_id in 0..width {
-        let child_name = child_id.to_string();
-        let child_path = parent.join(&child_name);
-        if depth == 1 {
-            let mut f = std::fs::File::create(&child_path)?;
-            rng.fill_bytes(&mut rand_buf);
-            f.write_all(&rand_buf)?;
-            f.flush()?;
-            modified_file_paths.insert(child_path);
-        } else {
-            std::fs::create_dir(&child_path)?;
-            create_directory_tree(modified_file_paths, &child_path, depth - 1, width)?;
-        }
-    }
-    Ok(())
-}
-
-fn create_initial_symlinks(
-    fs_root: &Path,
-    symlink_mode: SymlinkMode,
-    symlink_count: u32,
-    depth: usize,
-) -> anyhow::Result<Vec<PathBuf>> {
-    // Use a dedicated "symlinks" directory to avoid conflicts
-    let symlinks_dir = fs_root.join("_symlinks");
-    std::fs::create_dir_all(&symlinks_dir)?;
-
-    let initial_target_relative = match symlink_mode {
-        SymlinkMode::File => {
-            // Point to a file at depth: 0/0/0/.../0
-            let mut path = PathBuf::new();
-            for _ in 0..depth {
-                path.push("0");
-            }
-            path
-        }
-        SymlinkMode::Directory => PathBuf::from("0"),
-        #[cfg(windows)]
-        SymlinkMode::Junction => PathBuf::from("0"),
-    };
-
-    let relative_target = Path::new("..").join(&initial_target_relative);
-
-    let mut symlink_targets = Vec::new();
-    for i in 0..symlink_count {
-        let symlink_path = symlinks_dir.join(i.to_string());
-        create_symlink(&symlink_path, &relative_target, symlink_mode)?;
-        symlink_targets.push(initial_target_relative.clone());
-    }
-
-    Ok(symlink_targets)
-}
-
-fn create_symlink(link_path: &Path, target: &Path, mode: SymlinkMode) -> anyhow::Result<()> {
-    #[cfg(unix)]
-    {
-        let _ = mode;
-        std::os::unix::fs::symlink(target, link_path)?;
-    }
-    #[cfg(windows)]
-    {
-        match mode {
-            SymlinkMode::File => {
-                std::os::windows::fs::symlink_file(target, link_path)?;
-            }
-            SymlinkMode::Directory => {
-                std::os::windows::fs::symlink_dir(target, link_path)?;
-            }
-            SymlinkMode::Junction => {
-                // Junction points require absolute paths
-                let absolute_target = link_path.parent().unwrap_or(link_path).join(target);
-                std::os::windows::fs::junction_point(&absolute_target, link_path)?;
-            }
-        }
-    }
-    Ok(())
-}
-
-fn remove_symlink(link_path: &Path, mode: SymlinkMode) -> anyhow::Result<()> {
-    #[cfg(unix)]
-    {
-        let _ = mode;
-        std::fs::remove_file(link_path)?;
-    }
-    #[cfg(windows)]
-    {
-        match mode {
-            SymlinkMode::File | SymlinkMode::Directory => {
-                std::fs::remove_file(link_path)?;
-            }
-            SymlinkMode::Junction => {
-                std::fs::remove_dir(link_path)?;
-            }
-        }
-    }
-    Ok(())
-}
-
-fn pick_random_file(depth: usize, width: usize) -> PathBuf {
-    let mut rng = rand::rng();
-    iter::repeat_with(|| rng.random_range(0..width).to_string())
-        .take(depth)
-        .collect()
-}
-
-struct RandomDirectory {
-    depth: usize,
-    path: PathBuf,
-}
-
-fn pick_random_directory(max_depth: usize, width: usize) -> RandomDirectory {
-    let mut rng = rand::rng();
-    // never use a depth of 0 because that would be the root directory
-    let depth = rng.random_range(1..(max_depth - 1));
-    let path = iter::repeat_with(|| rng.random_range(0..width).to_string())
-        .take(depth)
-        .collect();
-    RandomDirectory { depth, path }
-}
-
-fn pick_random_link_target(depth: usize, width: usize, mode: SymlinkMode) -> PathBuf {
-    match mode {
-        SymlinkMode::File => pick_random_file(depth, width),
-        SymlinkMode::Directory => pick_random_directory(depth, width).path,
-        #[cfg(windows)]
-        SymlinkMode::Junction => pick_random_directory(depth, width).path,
-    }
-}
-
-struct FsCleanup<'a> {
-    path: &'a Path,
-}
-
-impl Drop for FsCleanup<'_> {
-    fn drop(&mut self) {
-        std::fs::remove_dir_all(self.path).unwrap();
+        Commands::FsWatcher(args) => fs_watcher::run(args).await,
     }
 }