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/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/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/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/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/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 { + const renderResumeDataCachesByPage: Record = {} + 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 | 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, @@ -664,23 +778,10 @@ async function exportAppImpl( results = await exportPagesInBatches(worker, initialPhaseExportPaths) if (finalPhaseExportPaths.length > 0) { - const renderResumeDataCachesByPage: Record = {} - - 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/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 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}`, 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 }) { const [result, formAction] = useActionState(action, 'initial') @@ -11,7 +10,6 @@ export function Form({ action }: { action: () => Promise }) {

Inline Server Action with Cache Components

{result}

-
{getSentinelValue()}
) } 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 = return ( -
{ - 'use server' - return ( - <> - {simpleValue} {jsxValue} {timedValue} - - ) - }} - /> + <> + { + 'use server' + return ( + <> + {simpleValue} {jsxValue} {timedValue} + + ) + }} + /> +
{getSentinelValue()}
+ ) } 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 } 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 ( +
+
Blog Article
+
Estimated reading time: 5 minutes
+ + Loading article...}> + + + + Loading comments...}> + + +
+ ) +} + +// 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 ( + <> +
+

{post.title}

+

Locale: {post.locale}

+

{post.content}

+
+ + + ) +} + +async function DynamicComments() { + const cookieStore = await cookies() + const user = cookieStore.get('user')?.value || 'anonymous' + return ( +
+

Comments

+

Viewing as: {user}

+
+ ) +} +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 ( + + +
Welcome to our Blog Platform
+ + + Loading locale info...} + > + + + + Loading user...}> + + + + {children} + + + ) +} + +// 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 ( +
+ Locale: {config.locale} +
+ {config.translations.home} | {config.translations.blog} |{' '} + {config.translations.about} +
+
+ ) +} + +async function UserInfo() { + const cookieStore = await cookies() + const user = cookieStore.get('user')?.value || 'anonymous' + return
Logged in as: {user}
+} + +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 ( +
+
+

Home

+

Welcome!

+
+
+ ) +} 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) + } + }) +}) 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 00000000000000..f22496d0b6c877 Binary files /dev/null and b/test/e2e/app-dir/worker/app/add.wasm differ 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 ( +
+ +

Worker state:

+

{state}

+
+ ) +} 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 ( +
+ +

Worker state:

+

{state}

+
+ ) +} 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/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 TurboTasksBackendInner { #[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 { + 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 TurboTasksBackendInner { .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 TurboTasksBackendInner { .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 TurboTasksBackendInner { .collect::>(); 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)), ); } 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, + /// 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>>); + +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::>(); + let mut missing = modified_file_paths + .difference(&absolute_path_invalidations) + .collect::>(); + 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::new(rcstr!("project"), fs_root) +} + +#[turbo_tasks::function(operation)] +fn disk_file_system_root_operation(fs: ResolvedVc) -> Vc { + fs.root() +} + +#[turbo_tasks::function] +async fn read_path( + invalidations: TransientInstance, + 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, + 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, + 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, + 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, + root: FileSystemPath, + depth: usize, + width: usize, + symlink_count: u32, + symlink_is_directory: Option, + write: bool, +) -> anyhow::Result<()> { + async fn process_paths_inner( + invalidations: TransientInstance, + 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, +) -> (usize, Vec) { + fn check_files_inner( + parent: &Path, + depth: usize, + width: usize, + total: &mut usize, + mismatched: &mut Vec, + ) { + 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 = 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, + 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> { + // 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 31a28ddf16d553..d82325d40b0936 100644 --- a/turbopack/crates/turbo-tasks-fuzz/src/main.rs +++ b/turbopack/crates/turbo-tasks-fuzz/src/main.rs @@ -1,22 +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, trace::TraceRawVcs}; -use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage}; -use turbo_tasks_fs::{DiskFileSystem, FileSystem, FileSystemPath}; +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. @@ -35,50 +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, - /// 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, -} - -#[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, + FsWatcher(fs_watcher::FsWatcher), } #[tokio::main] @@ -86,372 +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>>); - -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 read_all_paths_op = read_all_paths_operation( - invalidations.clone(), - project_root.clone(), - args.depth, - args.width, - if args.symlinks.is_some() { - args.symlink_count - } else { - 0 - }, - ); - read_all_paths_op.read_strongly_consistent().await?; - { - let mut invalidations = invalidations.0.lock().unwrap(); - println!("read all {} files", invalidations.len()); - invalidations.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; - read_all_paths_op.read_strongly_consistent().await?; - { - 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(), - symlink_info, - invalidations.len() - ); - if args.print_missing_invalidations { - let absolute_path_invalidations = invalidations - .iter() - .map(|relative_path| fs_root.join(relative_path)) - .collect::>(); - let mut missing = modified_file_paths - .difference(&absolute_path_invalidations) - .collect::>(); - 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::new(rcstr!("project"), fs_root) -} - -#[turbo_tasks::function(operation)] -fn disk_file_system_root_operation(fs: ResolvedVc) -> Vc { - fs.root() -} - -#[turbo_tasks::function] -async fn read_path( - invalidations: TransientInstance, - 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, - 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(operation)] -async fn read_all_paths_operation( - invalidations: TransientInstance, - root: FileSystemPath, - depth: usize, - width: usize, - symlink_count: u32, -) -> anyhow::Result<()> { - async fn read_all_paths_inner( - invalidations: TransientInstance, - parent: FileSystemPath, - depth: usize, - width: usize, - ) -> 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?; - } else { - Box::pin(read_all_paths_inner( - invalidations.clone(), - child_path, - depth - 1, - width, - )) - .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?; - } - - Ok(()) -} - -fn create_directory_tree( - modified_file_paths: &mut FxHashSet, - 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> { - // 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, } } 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) -> Result> { Ok(Vc::cell(self.await?.debug_ids)) } + + #[turbo_tasks::function] + fn worker_entrypoint( + self: Vc, + asset_context: Vc>, + ) -> Vc> { + 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>, + asset_context: ResolvedVc>, +} + +#[turbo_tasks::value_impl] +impl EcmascriptBrowserWorkerEntrypoint { + #[turbo_tasks::function] + pub async fn new( + chunking_context: ResolvedVc>, + asset_context: ResolvedVc>, + ) -> Result> { + Ok(EcmascriptBrowserWorkerEntrypoint { + chunking_context, + asset_context, + } + .cell()) + } + + #[turbo_tasks::function] + async fn code(self: Vc) -> Result> { + 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> { + 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) -> Result> { + 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 { + Vc::cell(rcstr!("Ecmascript Browser Worker Entrypoint")) + } +} + +#[turbo_tasks::value_impl] +impl OutputAssetsReference for EcmascriptBrowserWorkerEntrypoint { + #[turbo_tasks::function] + async fn references(self: Vc) -> Result> { + 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) -> Result> { + 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) -> Result> { + 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) -> Vc { + 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) -> Vc; -} + /// 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, + asset_context: Vc>, + ) -> Result>> { + let _ = asset_context; + bail!( + "Worker entrypoint is not supported by {name}", + name = self.name().await? + ); + } +} pub trait ChunkingContextExt { fn root_chunk_group( self: Vc, 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>) -> Result> { + 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>) -> Result> { let mut assets: FxIndexSet<_> = FxIndexSet::default(); @@ -161,26 +168,36 @@ impl OutputAssetsWithReferenced { #[turbo_tasks::function] pub async fn concatenate(&self, other: Vc) -> Result> { + 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>, + ) -> Result> { + 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> { 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 @@ /// /// -// 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 = 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 { 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>, + generate_source_map: bool, +) -> Result> { + 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, pub issue_source: IssueSource, pub in_try: bool, + pub worker_type: WorkerReferenceSubType, } impl WorkerAssetReference { @@ -42,25 +43,24 @@ impl WorkerAssetReference { request: ResolvedVc, 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>> { + async fn worker_loader_module(&self) -> Result>> { 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, pub module_graph: ResolvedVc, pub chunking_context: ResolvedVc>, + pub asset_context: ResolvedVc>, + pub worker_type: WorkerReferenceSubType, } #[turbo_tasks::value_impl] @@ -35,7 +39,6 @@ impl WorkerLoaderChunkItem { #[turbo_tasks::function] async fn chunk_group(&self) -> Result> { 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) -> Result> { + 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) -> Vc { - self.chunk_group() + async fn references(self: Vc) -> Result> { + 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>, + pub worker_type: WorkerReferenceSubType, + pub asset_context: ResolvedVc>, } #[turbo_tasks::value_impl] impl WorkerLoaderModule { #[turbo_tasks::function] - pub fn new(module: ResolvedVc>) -> Vc { - Self::cell(WorkerLoaderModule { inner: module }) + pub fn new( + module: ResolvedVc>, + worker_type: WorkerReferenceSubType, + asset_context: ResolvedVc>, + ) -> Vc { + 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, module_graph: ResolvedVc, chunking_context: ResolvedVc>, - ) -> Vc> { - Vc::upcast( + ) -> Result>> { + 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> { .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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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": 743, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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": 748, "column": 0}, "map": {"version":3,"sources":["turbopack:///[turbopack]/browser/runtime/base/dev-base.ts"],"sourcesContent":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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":"AAAA,2CAA2C;AAC3C,4CAA4C;AAC5C,4CAA4C;AAM5C,MAAMA,sBAAsBC,QAAQC,SAAS;AAE7C;;;;;;CAMC,GAED,oDAAoD,GAEpD,MAAMC,iBAAyCC,OAAOC,MAAM,CAAC;AAC7DL,oBAAoBM,CAAC,GAAGH;AAgCxB,MAAMI,yBAAyBC;IAC7BC,OAAO,mBAAkB;IAEzBC,gBAA2B;IAE3BH,YAAYI,OAAe,EAAED,eAA2B,CAAE;QACxD,KAAK,CAACC;QACN,IAAI,CAACD,eAAe,GAAGA;IACzB;AACF;AAEA;;CAEC,GACD,MAAME,iBAAgC,IAAIC;AAE1C;;;;;;CAMC,GACD,MAAMC,kBAAiD,IAAIC;AAC3D;;CAEC,GACD,MAAMC,kBAAiD,IAAID;AAC3D;;;;CAIC,GACD,MAAME,oBAAwC,IAAIJ;AAClD;;CAEC,GACD,MAAMK,qBAAyD,IAAIH;AACnE;;CAEC,GACD,MAAMI,qBAAyD,IAAIJ;AAEnE;;;CAGC,GACD,MAAMK,gBAAwC,IAAIL;AAClD;;CAEC,GACD,MAAMM,iBAAwC,IAAIN;AAClD;;CAEC,GACD,MAAMO,2BAA0C,IAAIT;AAEpD;;CAEC,GACD,aAAa;AACb,SAASU,8BACPC,SAAoB,EACpBC,QAAkB;IAElB,MAAMC,SAASvB,cAAc,CAACsB,SAAS;IACvC,IAAIC,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QACA,OAAOD;IACT;IAEA,aAAa;IACb,OAAOE,kBAAkBH,UAAUI,WAAWC,OAAO,EAAEN;AACzD;AAEA;;CAEC,GACD,2CAA2C;AAC3C,MAAMO,mCAEF,CAACC,IAAIC;IACP,IAAI,CAACA,aAAaC,GAAG,CAACC,MAAM,EAAE;QAC5BC,QAAQC,IAAI,CACV,CAAC,4BAA4B,EAAEL,GAAG,aAAa,EAAEC,aAAaD,EAAE,CAAC,oCAAoC,CAAC;IAE1G;IAEA,MAAMN,SAASvB,cAAc,CAAC6B,GAAG;IAEjC,IAAIC,aAAaK,QAAQ,CAACC,OAAO,CAACP,QAAQ,CAAC,GAAG;QAC5CC,aAAaK,QAAQ,CAACE,IAAI,CAACR;IAC7B;IAEA,IAAIN,QAAQ;QACV,IAAIA,OAAOC,KAAK,EAAE;YAChB,MAAMD,OAAOC,KAAK;QACpB;QAEA,IAAID,OAAOe,OAAO,CAACF,OAAO,CAACN,aAAaD,EAAE,MAAM,CAAC,GAAG;YAClDN,OAAOe,OAAO,CAACD,IAAI,CAACP,aAAaD,EAAE;QACrC;QAEA,OAAON;IACT;IAEA,OAAOE,kBAAkBI,IAAIH,WAAWa,MAAM,EAAET,aAAaD,EAAE;AACjE;AAEA,SAASW,WAEPjB,MAAiB,EACjBkB,OAAgB,EAChBC,OAAuB;IAEvB5C,QAAQ6C,IAAI,CAAC,IAAI,EAAEpB,QAAQkB;IAC3B,IAAI,CAACG,CAAC,GAAGF;AACX;AACAF,WAAWzC,SAAS,GAAGD,QAAQC,SAAS;AAUxC,SAAS0B,kBACPH,QAAkB,EAClBuB,UAAsB,EACtBC,UAAsB;IAEtB,kDAAkD;IAClD,IAAIjB,KAAKP;IAET,MAAMyB,gBAAgBC,gBAAgBC,GAAG,CAACpB;IAC1C,IAAI,OAAOkB,kBAAkB,YAAY;QACvC,sEAAsE;QACtE,0EAA0E;QAC1E,mDAAmD;QACnD,MAAM,IAAI1C,MACR6C,2BAA2BrB,IAAIgB,YAAYC,cACzC;IAEN;IAEA,MAAMK,UAAUlC,cAAcgC,GAAG,CAACpB;IAClC,MAAM,EAAEE,GAAG,EAAEqB,QAAQ,EAAE,GAAGC,gBAAgBxB,IAAIsB;IAE9C,IAAIb;IACJ,OAAQO;QACN,KAAKnB,WAAWC,OAAO;YACrBlB,eAAe6C,GAAG,CAACzB;YACnBS,UAAU,EAAE;YACZ;QACF,KAAKZ,WAAWa,MAAM;YACpB,wEAAwE;YACxE,wEAAwE;YACxED,UAAU;gBAACQ;aAAuB;YAClC;QACF,KAAKpB,WAAW6B,MAAM;YACpBjB,UAAU,AAACQ,cAA6B,EAAE;YAC1C;QACF;YACEU,UACEX,YACA,CAACA,aAAe,CAAC,qBAAqB,EAAEA,YAAY;IAE1D;IAEA,MAAMtB,SAAoBkC,mBAAmB5B;IAC7C,MAAMY,UAAUlB,OAAOkB,OAAO;IAC9BlB,OAAOe,OAAO,GAAGA;IACjBf,OAAOY,QAAQ,GAAG,EAAE;IACpBZ,OAAOQ,GAAG,GAAGA;IAEb/B,cAAc,CAAC6B,GAAG,GAAGN;IACrBL,eAAewC,GAAG,CAACnC,QAAQ6B;IAE3B,4EAA4E;IAC5E,IAAI;QACFO,wBAAwBpC,QAAQ,CAACmB;YAC/B,MAAMkB,UAAU,IAAKpB,WACnBjB,QACAkB,SACAC;YAEFK,cAAca,SAASrC,QAAQkB;QACjC;IACF,EAAE,OAAOjB,OAAO;QACdD,OAAOC,KAAK,GAAGA;QACf,MAAMA;IACR;IAEA,IAAID,OAAOsC,eAAe,IAAItC,OAAOkB,OAAO,KAAKlB,OAAOsC,eAAe,EAAE;QACvE,yDAAyD;QACzDC,WAAWvC,OAAOkB,OAAO,EAAElB,OAAOsC,eAAe;IACnD;IAEA,OAAOtC;AACT;AAEA,MAAMwC,wBAAwB;IAC5BC,UAAU,CAACC,OAAgBC,OAAkB;IAC7CC,WAAW,IAAM,CAACF,SAAoB;IACtCG,iBAAiB,CAACC,SAAkBC,YAAuB;AAC7D;AAEA;;;;CAIC,GACD,SAASX,wBACPpC,MAAiB,EACjBgD,aAA4C;IAE5C,IAAI,OAAOC,WAAWC,iCAAiC,KAAK,YAAY;QACtE,MAAMC,+BACJF,WAAWC,iCAAiC,CAAClD,OAAOM,EAAE;QACxD,IAAI;YACF0C,cAAc;gBACZP,UAAUQ,WAAWG,YAAY;gBACjCR,WAAWK,WAAWI,YAAY;gBAClCR,iBAAiBS;YACnB;QACF,SAAU;YACR,iEAAiE;YACjEH;QACF;IACF,OAAO;QACL,gFAAgF;QAChF,+EAA+E;QAC/E,yBAAyB;QACzBH,cAAcR;IAChB;AACF;AAEA;;CAEC,GACD,SAASc,+CACPtD,MAAiB,EACjBuD,OAAuB;IAEvB,MAAMC,iBAAiBxD,OAAOkB,OAAO;IACrC,MAAMuC,cAAczD,OAAOQ,GAAG,CAACkD,IAAI,CAACD,WAAW,IAAI;IAEnDF,QAAQI,8BAA8B,CAACH,gBAAgBxD,OAAOM,EAAE;IAEhE,yEAAyE;IACzE,4BAA4B;IAC5B,IAAIiD,QAAQK,sBAAsB,CAACJ,iBAAiB;QAClD,sEAAsE;QACtE,cAAc;QACdxD,OAAOQ,GAAG,CAACqD,OAAO,CAAC,CAACH;YAClBA,KAAKD,WAAW,GAAGD;QACrB;QACA,uEAAuE;QACvE,kCAAkC;QAClCxD,OAAOQ,GAAG,CAACsD,MAAM;QAEjB,mEAAmE;QACnE,yEAAyE;QACzE,qBAAqB;QACrB,IAAIL,gBAAgB,MAAM;YACxB,mEAAmE;YACnE,6BAA6B;YAC7B,EAAE;YACF,+DAA+D;YAC/D,kEAAkE;YAClE,8DAA8D;YAC9D,gDAAgD;YAChD,IACEF,QAAQQ,oCAAoC,CAC1CR,QAAQS,2BAA2B,CAACP,cACpCF,QAAQS,2BAA2B,CAACR,kBAEtC;gBACAxD,OAAOQ,GAAG,CAACyD,UAAU;YACvB,OAAO;gBACLV,QAAQW,cAAc;YACxB;QACF;IACF,OAAO;QACL,yEAAyE;QACzE,uDAAuD;QACvD,oEAAoE;QACpE,oEAAoE;QACpE,MAAMC,sBAAsBV,gBAAgB;QAC5C,IAAIU,qBAAqB;YACvBnE,OAAOQ,GAAG,CAACyD,UAAU;QACvB;IACF;AACF;AAEA,SAASG,sBAAsBpF,eAA2B;IACxD,OAAO,CAAC,kBAAkB,EAAEA,gBAAgBqF,IAAI,CAAC,SAAS;AAC5D;AAEA,SAASC,uBACPC,KAAuD,EACvDC,QAA8C;IAK9C,MAAMC,qBAAqB,IAAIpF;IAE/B,KAAK,MAAM,CAACU,UAAU2E,MAAM,IAAIH,MAAO;QACrC,IAAIG,SAAS,MAAM;YACjBD,mBAAmBtC,GAAG,CAACpC,UAAU4E,MAAMD;QACzC;IACF;IAEA,MAAME,kBAAkBC,2BAA2BL,SAASM,IAAI;IAEhE,KAAK,MAAM,CAAC/E,UAAU2E,MAAM,IAAIF,SAAU;QACxCC,mBAAmBtC,GAAG,CAACpC,UAAU4E,MAAMD;IACzC;IAEA,OAAO;QAAEE;QAAiBH;IAAmB;AAC/C;AAEA,SAASI,2BACPE,WAA+B;IAE/B,MAAMH,kBAAkB,IAAIzF;IAE5B,KAAK,MAAMY,YAAYgF,YAAa;QAClC,MAAMC,SAASC,yBAAyBlF;QAExC,OAAQiF,OAAOE,IAAI;YACjB,KAAK;gBACH,MAAM,IAAIrG,iBACR,CAAC,wCAAwC,EAAEuF,sBACzCY,OAAOhG,eAAe,EACtB,CAAC,CAAC,EACJgG,OAAOhG,eAAe;YAE1B,KAAK;gBACH,MAAM,IAAIH,iBACR,CAAC,2CAA2C,EAAEuF,sBAC5CY,OAAOhG,eAAe,EACtB,CAAC,CAAC,EACJgG,OAAOhG,eAAe;YAE1B,KAAK;gBACH,KAAK,MAAMmG,oBAAoBH,OAAOJ,eAAe,CAAE;oBACrDA,gBAAgB7C,GAAG,CAACoD;gBACtB;gBACA;YACF,6DAA6D;YAC7D;gBACElD,UAAU+C,QAAQ,CAACA,SAAW,CAAC,qBAAqB,EAAEA,QAAQE,MAAM;QACxE;IACF;IAEA,OAAON;AACT;AAEA,SAASQ,mCACPR,eAAmC;IAEnC,MAAMS,8BAGA,EAAE;IACR,KAAK,MAAMtF,YAAY6E,gBAAiB;QACtC,MAAM5E,SAASvB,cAAc,CAACsB,SAAS;QACvC,MAAM8B,WAAWlC,eAAe+B,GAAG,CAAC1B;QACpC,IAAIA,UAAU6B,SAASyD,YAAY,IAAI,CAACzD,SAAS0D,eAAe,EAAE;YAChEF,4BAA4BvE,IAAI,CAAC;gBAC/Bf;gBACAyF,cAAc3D,SAASyD,YAAY;YACrC;QACF;IACF;IACA,OAAOD;AACT;AAEA;;;;CAIC,GACD,SAASI,kBACPC,kBAAiD,EACjDC,oBAAmD;IAEnD,KAAK,MAAM,CAAC7F,WAAW8F,eAAe,IAAIF,mBAAoB;QAC5D,KAAK,MAAM3F,YAAY6F,eAAgB;YACrCC,iBAAiB9F,UAAUD;QAC7B;IACF;IAEA,MAAMgG,kBAAiC,IAAI3G;IAC3C,KAAK,MAAM,CAACW,WAAW8F,eAAe,IAAID,qBAAsB;QAC9D,KAAK,MAAM5F,YAAY6F,eAAgB;YACrC,IAAIG,sBAAsBhG,UAAUD,YAAY;gBAC9CgG,gBAAgB/D,GAAG,CAAChC;YACtB;QACF;IACF;IAEA,OAAO;QAAE+F;IAAgB;AAC3B;AAEA,SAASE,aACPpB,eAAmC,EACnCkB,eAAmC;IAEnC,KAAK,MAAM/F,YAAY6E,gBAAiB;QACtCqB,cAAclG,UAAU;IAC1B;IAEA,KAAK,MAAMA,YAAY+F,gBAAiB;QACtCG,cAAclG,UAAU;IAC1B;IAEA,6DAA6D;IAC7D,0EAA0E;IAC1E,MAAMmG,wBAAwB,IAAI7G;IAClC,KAAK,MAAMU,YAAY6E,gBAAiB;QACtC,MAAMuB,YAAY1H,cAAc,CAACsB,SAAS;QAC1CmG,sBAAsB/D,GAAG,CAACpC,UAAUoG,WAAWpF;QAC/C,OAAOtC,cAAc,CAACsB,SAAS;IACjC;IAEA,uEAAuE;IACvE,YAAY;IAEZ,OAAO;QAAEmG;IAAsB;AACjC;AAEA;;;;;;;;;;;;CAYC,GACD,SAASD,cAAclG,QAAkB,EAAEqG,IAAyB;IAClE,MAAMpG,SAASvB,cAAc,CAACsB,SAAS;IACvC,IAAI,CAACC,QAAQ;QACX;IACF;IAEA,MAAM6B,WAAWlC,eAAe+B,GAAG,CAAC1B;IACpC,MAAM0D,OAAO,CAAC;IAEd,mEAAmE;IACnE,qBAAqB;IACrB,KAAK,MAAM2C,kBAAkBxE,SAASyE,eAAe,CAAE;QACrDD,eAAe3C;IACjB;IAEA,0EAA0E;IAC1E,2CAA2C;IAC3C1D,OAAOQ,GAAG,CAACC,MAAM,GAAG;IAEpBd,eAAe4G,MAAM,CAACvG;IAEtB,sEAAsE;IAEtE,8DAA8D;IAC9D,wEAAwE;IACxE,kBAAkB;IAClB,KAAK,MAAMwG,WAAWxG,OAAOY,QAAQ,CAAE;QACrC,MAAM6F,QAAQhI,cAAc,CAAC+H,QAAQ;QACrC,IAAI,CAACC,OAAO;YACV;QACF;QAEA,MAAMC,MAAMD,MAAM1F,OAAO,CAACF,OAAO,CAACb,OAAOM,EAAE;QAC3C,IAAIoG,OAAO,GAAG;YACZD,MAAM1F,OAAO,CAAC4F,MAAM,CAACD,KAAK;QAC5B;IACF;IAEA,OAAQN;QACN,KAAK;YACH,OAAO3H,cAAc,CAACuB,OAAOM,EAAE,CAAC;YAChCZ,cAAc6G,MAAM,CAACvG,OAAOM,EAAE;YAC9B;QACF,KAAK;YACHZ,cAAcyC,GAAG,CAACnC,OAAOM,EAAE,EAAEoD;YAC7B;QACF;YACEzB,UAAUmE,MAAM,CAACA,OAAS,CAAC,cAAc,EAAEA,MAAM;IACrD;AACF;AAEA,SAASQ,WACPvB,2BAGG,EACHZ,kBAAgD,EAChDyB,qBAAqD,EACrDW,WAA+B;IAE/B,2BAA2B;IAC3B,KAAK,MAAM,CAAC9G,UAAU+G,QAAQ,IAAIrC,mBAAmBsC,OAAO,GAAI;QAC9DC,uBAAuBF;QACvBrF,gBAAgBU,GAAG,CAACpC,UAAU+G;IAChC;IAEA,gDAAgD;IAEhD,wEAAwE;IAExE,qDAAqD;IACrD,KAAK,MAAM,EAAE/G,QAAQ,EAAEyF,YAAY,EAAE,IAAIH,4BAA6B;QACpE,IAAI;YACFnF,kBACEH,UACAI,WAAW6B,MAAM,EACjBkE,sBAAsBxE,GAAG,CAAC3B;QAE9B,EAAE,OAAOkH,KAAK;YACZ,IAAI,OAAOzB,iBAAiB,YAAY;gBACtC,IAAI;oBACFA,aAAayB,KAAK;wBAAElH;wBAAUC,QAAQvB,cAAc,CAACsB,SAAS;oBAAC;gBACjE,EAAE,OAAOmH,MAAM;oBACbL,YAAYK;oBACZL,YAAYI;gBACd;YACF,OAAO;gBACLJ,YAAYI;YACd;QACF;IACF;AACF;AAEA,SAASE,YAAYC,MAAqB;IACxC,OAAQA,OAAOlC,IAAI;QACjB,KAAK;YACHmC,qBAAqBD;YACrB;QACF;YACEnF,UAAUmF,QAAQ,CAACA,SAAW,CAAC,qBAAqB,EAAEA,OAAOlC,IAAI,EAAE;IACvE;AACF;AAEA,SAASmC,qBAAqBD,MAAuB;IACnD,IAAIA,OAAOE,MAAM,IAAI,MAAM;QACzB,KAAK,MAAMA,UAAUF,OAAOE,MAAM,CAAE;YAClC,OAAQA,OAAOpC,IAAI;gBACjB,KAAK;oBACHqC,4BAA4BD;oBAC5B;gBACF;oBACErF,UAAUqF,QAAQ,CAACA,SAAW,CAAC,qBAAqB,EAAEA,OAAOpC,IAAI,EAAE;YACvE;QACF;IACF;IAEA,IAAIkC,OAAOI,MAAM,IAAI,MAAM;QACzB,KAAK,MAAM,CAAC1H,WAAW2H,YAAY,IAAI/I,OAAOqI,OAAO,CACnDK,OAAOI,MAAM,EACuB;YACpC,MAAME,WAAWC,oBAAoB7H;YAErC,OAAQ2H,YAAYvC,IAAI;gBACtB,KAAK;oBACH0C,QAAQC,eAAe,CAAC1H,WAAW6B,MAAM,EAAE0F;oBAC3C;gBACF,KAAK;oBACHI,YAAYC,WAAW,GAAGL;oBAC1B;gBACF,KAAK;oBACHI,YAAYE,WAAW,GAAGN;oBAC1B;gBACF,KAAK;oBACHzF,UACEwF,YAAYQ,WAAW,EACvB,CAACA,cACC,CAAC,6BAA6B,EAAEC,KAAKC,SAAS,CAACF,aAAa,CAAC,CAAC;oBAElE;gBACF;oBACEhG,UACEwF,aACA,CAACA,cAAgB,CAAC,2BAA2B,EAAEA,YAAYvC,IAAI,EAAE;YAEvE;QACF;IACF;AACF;AAEA,SAASqC,4BAA4BH,MAA8B;IACjE,MAAM,EAAEL,UAAU,CAAC,CAAC,EAAES,SAAS,CAAC,CAAC,EAAE,GAAGJ;IACtC,MAAM,EAAE7C,KAAK,EAAEC,QAAQ,EAAE4D,WAAW,EAAEC,aAAa,EAAE,GAAGC,sBACtDvB,SACAS;IAEF,MAAM,EAAE5C,eAAe,EAAEH,kBAAkB,EAAE,GAAGH,uBAC9CC,OACAC;IAEF,MAAM,EAAEsB,eAAe,EAAE,GAAGL,kBAAkB2C,aAAaC;IAE3DE,cAAc3D,iBAAiBkB,iBAAiBrB;AAClD;AAEA,SAAS+D,wBAAwB5D,eAA8B;IAC7D,IAAIhF,yBAAyB6I,IAAI,GAAG,GAAG;QACrC5D,2BAA2BjF,0BAA0B8I,OAAO,CAAC,CAAC3I;YAC5D6E,gBAAgB7C,GAAG,CAAChC;QACtB;QAEAH,yBAAyB+I,KAAK;IAChC;IAEA,OAAO/D;AACT;AAEA,SAAS2D,cACP3D,eAA8B,EAC9BkB,eAAmC,EACnCrB,kBAAgD;IAEhDG,kBAAkB4D,wBAAwB5D;IAE1C,MAAMS,8BACJD,mCAAmCR;IAErC,MAAM,EAAEsB,qBAAqB,EAAE,GAAGF,aAChCpB,iBACAkB;IAGF,4FAA4F;IAC5F,IAAI7F;IAEJ,SAAS4G,YAAYI,GAAQ;QAC3B,IAAI,CAAChH,OAAOA,QAAQgH;IACtB;IAEAL,WACEvB,6BACAZ,oBACAyB,uBACAW;IAGF,IAAI5G,OAAO;QACT,MAAMA;IACR;IAEA,IAAIL,yBAAyB6I,IAAI,GAAG,GAAG;QACrCF,cAAc,IAAIpJ,OAAO,EAAE,EAAE,IAAIE;IACnC;AACF;AAEA,SAASiJ,sBACPvB,OAAgD,EAChD6B,OAAuD;IAQvD,MAAMR,cAAc,IAAI/I;IACxB,MAAMgJ,gBAAgB,IAAIhJ;IAC1B,MAAMkF,QAA8C,IAAIlF;IACxD,MAAMmF,WAAW,IAAInF;IACrB,MAAMwJ,UAAyB,IAAI1J;IAEnC,KAAK,MAAM,CAACW,WAAWgJ,kBAAkB,IAAIpK,OAAOqI,OAAO,CAAC6B,SAEzD;QACD,OAAQE,kBAAkB5D,IAAI;YAC5B,KAAK;gBAAS;oBACZ,MAAM6D,cAAc,IAAI5J,IAAI2J,kBAAkBE,OAAO;oBACrD,KAAK,MAAMjJ,YAAYgJ,YAAa;wBAClCxE,MAAMpC,GAAG,CAACpC,UAAUgH,OAAO,CAAChH,SAAS;oBACvC;oBACAqI,YAAYjG,GAAG,CAACrC,WAAWiJ;oBAC3B;gBACF;YACA,KAAK;gBAAW;oBACd,sDAAsD;oBACtD,MAAME,gBAAgB,IAAI9J,IAAIG,gBAAgBoC,GAAG,CAAC5B;oBAClD,KAAK,MAAMC,YAAYkJ,cAAe;wBACpCJ,QAAQ9G,GAAG,CAAChC;oBACd;oBACAsI,cAAclG,GAAG,CAACrC,WAAWmJ;oBAC7B;gBACF;YACA,KAAK;gBAAW;oBACd,MAAMF,cAAc,IAAI5J,IAAI2J,kBAAkBvE,KAAK;oBACnD,MAAM0E,gBAAgB,IAAI9J,IAAI2J,kBAAkBD,OAAO;oBACvD,KAAK,MAAM9I,YAAYgJ,YAAa;wBAClCxE,MAAMpC,GAAG,CAACpC,UAAUgH,OAAO,CAAChH,SAAS;oBACvC;oBACA,KAAK,MAAMA,YAAYkJ,cAAe;wBACpCJ,QAAQ9G,GAAG,CAAChC;oBACd;oBACAqI,YAAYjG,GAAG,CAACrC,WAAWiJ;oBAC3BV,cAAclG,GAAG,CAACrC,WAAWmJ;oBAC7B;gBACF;YACA;gBACEhH,UACE6G,mBACA,CAACA,oBACC,CAAC,kCAAkC,EAAEA,kBAAkB5D,IAAI,EAAE;QAErE;IACF;IAEA,oFAAoF;IACpF,yFAAyF;IACzF,uCAAuC;IACvC,KAAK,MAAMnF,YAAYwE,MAAMO,IAAI,GAAI;QACnC,IAAI+D,QAAQK,GAAG,CAACnJ,WAAW;YACzBwE,MAAMgC,MAAM,CAACxG;YACb8I,QAAQtC,MAAM,CAACxG;QACjB;IACF;IAEA,KAAK,MAAM,CAACA,UAAU2E,MAAM,IAAIhG,OAAOqI,OAAO,CAACA,SAAU;QACvD,gFAAgF;QAChF,kBAAkB;QAClB,gFAAgF;QAChF,kDAAkD;QAClD,IAAI,CAACxC,MAAM2E,GAAG,CAACnJ,WAAW;YACxByE,SAASrC,GAAG,CAACpC,UAAU2E;QACzB;IACF;IAEA,OAAO;QAAEH;QAAOsE;QAASrE;QAAU4D;QAAaC;IAAc;AAChE;AAkBA,SAASpD,yBAAyBlF,QAAkB;IAClD,MAAM6E,kBAAiC,IAAIzF;IAI3C,MAAMgK,QAAqB;QACzB;YACEpJ;YACAf,iBAAiB,EAAE;QACrB;KACD;IAED,IAAIoK;IACJ,MAAQA,WAAWD,MAAME,KAAK,GAAK;QACjC,MAAM,EAAEtJ,QAAQ,EAAEf,eAAe,EAAE,GAAGoK;QAEtC,IAAIrJ,YAAY,MAAM;YACpB,IAAI6E,gBAAgBsE,GAAG,CAACnJ,WAAW;gBAEjC;YACF;YAEA6E,gBAAgB7C,GAAG,CAAChC;QACtB;QAEA,sEAAsE;QACtE,qCAAqC;QACrC,IAAIA,aAAauJ,WAAW;YAC1B,OAAO;gBACLpE,MAAM;gBACNlG;YACF;QACF;QAEA,MAAMgB,SAASvB,cAAc,CAACsB,SAAS;QACvC,MAAM8B,WAAWlC,eAAe+B,GAAG,CAAC1B;QAEpC,IACE,qEAAqE;QACrE,0DAA0D;QAC1D,CAACA,UAEA6B,SAASyD,YAAY,IAAI,CAACzD,SAAS0D,eAAe,EACnD;YACA;QACF;QAEA,IAAI1D,SAAS0H,YAAY,EAAE;YACzB,OAAO;gBACLrE,MAAM;gBACNlG;gBACAe;YACF;QACF;QAEA,IAAIb,eAAegK,GAAG,CAACnJ,WAAW;YAChCoJ,MAAMrI,IAAI,CAAC;gBACTf,UAAUuJ;gBACVtK,iBAAiB;uBAAIA;oBAAiBe;iBAAS;YACjD;YACA;QACF;QAEA,KAAK,MAAMyJ,YAAYxJ,OAAOe,OAAO,CAAE;YACrC,MAAM0I,SAAShL,cAAc,CAAC+K,SAAS;YAEvC,IAAI,CAACC,QAAQ;gBAEX;YACF;YAEA,4DAA4D;YAC5D,qBAAqB;YAErBN,MAAMrI,IAAI,CAAC;gBACTf,UAAUyJ;gBACVxK,iBAAiB;uBAAIA;oBAAiBe;iBAAS;YACjD;QACF;IACF;IAEA,OAAO;QACLmF,MAAM;QACNnF;QACA6E;IACF;AACF;AAEA,SAAS8E,YAAYC,aAA4B,EAAEvC,MAAqB;IACtE,OAAQA,OAAOlC,IAAI;QACjB,KAAK;YAAW;gBACd,4FAA4F;gBAC5FiC,YAAYC,OAAOa,WAAW;gBAC9B;YACF;QACA,KAAK;YAAW;gBACd,iEAAiE;gBACjE,qEAAqE;gBACrE,aAAa;gBACbH,YAAY8B,OAAO;gBACnB;YACF;QACA,KAAK;YAAY;gBACf,+GAA+G;gBAC/G,kCAAkC;gBAClC,mGAAmG;gBACnG,6DAA6D;gBAC7D,IAAIrK,kBAAkB2J,GAAG,CAACS,gBAAgB;oBACxC7B,YAAY8B,OAAO;gBACrB,OAAO;oBACLC,iBAAiBF;gBACnB;gBACA;YACF;QACA;YACE,MAAM,IAAI7K,MAAM,CAAC,qBAAqB,EAAEsI,OAAOlC,IAAI,EAAE;IACzD;AACF;AAEA,SAASpD,gBACP/B,QAAkB,EAClB6B,OAAgB;IAEhB,MAAMC,WAAqB;QACzByD,cAAc;QACdiE,cAAc;QACdhE,iBAAiB;QACjBe,iBAAiB,EAAE;IACrB;IAEA,MAAM9F,MAAW;QACf,qEAAqE;QACrE,wEAAwE;QACxE,uCAAuC;QACvCC,QAAQ;QAERiD,MAAM9B,WAAW,CAAC;QAElB,mEAAmE;QACnEkC,QAAQ,CACNkF,SACAc,WACAC;YAEA,IAAIf,YAAYM,WAAW;gBACzBzH,SAASyD,YAAY,GAAG;YAC1B,OAAO,IAAI,OAAO0D,YAAY,YAAY;gBACxCnH,SAASyD,YAAY,GAAG0D;YAC1B,OAAO;gBACL,MAAM,IAAIlK,MAAM;YAClB;QACF;QAEAkL,SAAS,CAACC;YACR,IAAIA,QAAQX,WAAW;gBACrBzH,SAAS0H,YAAY,GAAG;YAC1B,OAAO;gBACL,MAAM,IAAIzK,MAAM;YAClB;QACF;QAEA+E,SAAS,CAACqG;YACRrI,SAASyE,eAAe,CAACxF,IAAI,CAACoJ;QAChC;QAEAC,mBAAmB,CAACD;YAClBrI,SAASyE,eAAe,CAACxF,IAAI,CAACoJ;QAChC;QAEAE,sBAAsB,CAACF;YACrB,MAAMxD,MAAM7E,SAASyE,eAAe,CAACzF,OAAO,CAACqJ;YAC7C,IAAIxD,OAAO,GAAG;gBACZ7E,SAASyE,eAAe,CAACK,MAAM,CAACD,KAAK;YACvC;QACF;QAEAzC,YAAY;YACVpC,SAAS0D,eAAe,GAAG;YAC3B3F,yBAAyBmC,GAAG,CAAChC;QAC/B;QAEA,qEAAqE;QACrE,uEAAuE;QACvE,iCAAiC;QACjCsK,QAAQ,IAAM;QAEd,2EAA2E;QAC3EC,kBAAkB,CAACC,YAAc;QACjCC,qBAAqB,CAACD,YAAc;QAEpC,2EAA2E;QAC3E,yEAAyE;QACzE,iBAAiB;QACjBE,OAAO,IAAMC,QAAQC,OAAO,CAAC;IAC/B;IAEA,OAAO;QAAEnK;QAAKqB;IAAS;AACzB;AAEA;;;CAGC,GACD,SAASkE,sBACPhG,QAAkB,EAClBD,SAAoB;IAEpB,MAAM8K,eAAexL,gBAAgBsC,GAAG,CAAC3B;IACzC6K,aAAarE,MAAM,CAACzG;IAEpB,MAAM+K,eAAevL,gBAAgBoC,GAAG,CAAC5B;IACzC+K,aAAatE,MAAM,CAACxG;IAEpB,MAAM+K,qBAAqBD,aAAapC,IAAI,KAAK;IACjD,IAAIqC,oBAAoB;QACtBxL,gBAAgBiH,MAAM,CAACzG;IACzB;IAEA,MAAMiL,oBAAoBH,aAAanC,IAAI,KAAK;IAChD,IAAIsC,mBAAmB;QACrB3L,gBAAgBmH,MAAM,CAACxG;IACzB;IAEA,OAAOgL;AACT;AAEA;;CAEC,GACD,SAASlB,iBAAiBF,aAA4B;IACpD,MAAMqB,aAAaxL,mBAAmBkC,GAAG,CAACiI;IAC1C,IAAIqB,cAAc,MAAM;QACtB,OAAO;IACT;IACAxL,mBAAmB+G,MAAM,CAACoD;IAE1B,KAAK,MAAM7J,aAAakL,WAAY;QAClC,MAAMC,kBAAkBxL,mBAAmBiC,GAAG,CAAC5B;QAC/CmL,gBAAgB1E,MAAM,CAACoD;QAEvB,IAAIsB,gBAAgBxC,IAAI,KAAK,GAAG;YAC9BhJ,mBAAmB8G,MAAM,CAACzG;YAC1BoL,aAAapL;QACf;IACF;IAEA,yEAAyE;IACzE,sCAAsC;IACtC,MAAMqL,eAAexD,oBAAoBgC;IAEzC7B,YAAYE,WAAW,GAAGmD;IAE1B,OAAO;AACT;AAEA;;;;CAIC,GACD,SAASD,aAAapL,SAAoB;IACxC,MAAM4H,WAAWC,oBAAoB7H;IACrC,qEAAqE;IACrE,wFAAwF;IACxFgI,YAAYE,WAAW,GAAGN;IAE1B,MAAMmD,eAAevL,gBAAgBoC,GAAG,CAAC5B;IACzC,IAAI+K,gBAAgB,MAAM;QACxB,OAAO;IACT;IACAA,aAAatE,MAAM,CAACzG;IAEpB,KAAK,MAAMC,YAAY8K,aAAc;QACnC,MAAMD,eAAexL,gBAAgBsC,GAAG,CAAC3B;QACzC6K,aAAarE,MAAM,CAACzG;QAEpB,MAAMiL,oBAAoBH,aAAanC,IAAI,KAAK;QAChD,IAAIsC,mBAAmB;YACrB3L,gBAAgBmH,MAAM,CAACxG;YACvBkG,cAAclG,UAAU;YACxBqL,iBAAiB7E,MAAM,CAACxG;QAC1B;IACF;IAEA,OAAO;AACT;AAEA;;CAEC,GACD,SAAS8F,iBAAiB9F,QAAkB,EAAED,SAAoB;IAChE,IAAI8K,eAAexL,gBAAgBsC,GAAG,CAAC3B;IACvC,IAAI,CAAC6K,cAAc;QACjBA,eAAe,IAAIzL,IAAI;YAACW;SAAU;QAClCV,gBAAgB+C,GAAG,CAACpC,UAAU6K;IAChC,OAAO;QACLA,aAAa7I,GAAG,CAACjC;IACnB;IAEA,IAAI+K,eAAevL,gBAAgBoC,GAAG,CAAC5B;IACvC,IAAI,CAAC+K,cAAc;QACjBA,eAAe,IAAI1L,IAAI;YAACY;SAAS;QACjCT,gBAAgB6C,GAAG,CAACrC,WAAW+K;IACjC,OAAO;QACLA,aAAa9I,GAAG,CAAChC;IACnB;AACF;AAEA;;;;CAIC,GACD,SAASsL,uBAAuB1B,aAA4B;IAC1DpK,kBAAkBwC,GAAG,CAAC4H;AACxB;AAEA,SAAS2B,cAAcC,YAA+B;IACpD,MAAMzL,YAAY0L,kBAAkBD,YAAY,CAAC,EAAE;IACnD,IAAIE;IACJ,8GAA8G;IAC9G,IAAIF,aAAaG,MAAM,KAAK,GAAG;QAC7BD,gBAAgBF,YAAY,CAAC,EAAE;IACjC,OAAO;QACLE,gBAAgBnC;QAChBqC,iCACEJ,cACA,WAAW,GAAG,GACd9J,iBACA,CAACnB,KAAiBuF,iBAAiBvF,IAAIR;IAE3C;IACA,OAAO8H,QAAQ0D,aAAa,CAACxL,WAAW2L;AAC1C;AAEA;;CAEC,GACD,SAASG,kBAAkBC,SAAoB;IAC7C,MAAMC,kBAAkBD,UAAUE,MAAM;IACxC,MAAMpC,gBAAgB6B,kBAAkBM;IACxC,sEAAsE;IACtElE,QAAQ0D,aAAa,CAAC3B;IACtB1G,WAAW+I,gCAAgC,CAAElL,IAAI,CAAC;QAChD6I;QACAD,YAAYuC,IAAI,CAAC,MAAMtC;KACxB;IAED,+CAA+C;IAC/C,MAAMqB,aAAa,IAAI7L,IAAI0M,UAAUrE,MAAM,CAAC0E,GAAG,CAACC;IAChD3M,mBAAmB2C,GAAG,CAACwH,eAAeqB;IACtC,KAAK,MAAMlL,aAAakL,WAAY;QAClC,IAAIC,kBAAkBxL,mBAAmBiC,GAAG,CAAC5B;QAC7C,IAAI,CAACmL,iBAAiB;YACpBA,kBAAkB,IAAI9L,IAAI;gBAACwK;aAAc;YACzClK,mBAAmB0C,GAAG,CAACrC,WAAWmL;QACpC,OAAO;YACLA,gBAAgBlJ,GAAG,CAAC4H;QACtB;IACF;IAEA,IAAIkC,UAAUO,MAAM,KAAK,SAAS;QAChCf,uBAAuB1B;IACzB;AACF;AAEA1G,WAAW+I,gCAAgC,KAAK,EAAE","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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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 */ /// /// -// 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":["/// \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/// \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 {\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 {\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/// \n/// \n/// \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\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext {\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 = 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,\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()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise = Promise.resolve(undefined)\nconst chunkCache = new Map>()\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,\n chunkData: ChunkData\n): Promise {\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,\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)(\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/// \n/// \n/// \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\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext {\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 = 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,\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()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise = Promise.resolve(undefined)\nconst chunkCache = new Map>()\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,\n chunkData: ChunkData\n): Promise {\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,\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)(\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":["/// \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/// \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 {\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 {\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/// \n/// \n/// \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\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext {\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 = 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,\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()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise = Promise.resolve(undefined)\nconst chunkCache = new Map>()\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,\n chunkData: ChunkData\n): Promise {\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,\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)(\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/// \n/// \n/// \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\ntype SourceData = ChunkPath | ModuleId\n\nprocess.env.TURBOPACK = '1'\n\ninterface TurbopackNodeBuildContext extends TurbopackBaseContext {\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 = 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,\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()\nconst unsupportedLoadChunk = Promise.resolve(undefined)\nconst loadedChunk: Promise = Promise.resolve(undefined)\nconst chunkCache = new Map>()\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,\n chunkData: ChunkData\n): Promise {\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,\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)(\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 */ /// /// -// 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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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/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 */ /// /// -// 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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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":"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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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n\nconst moduleCache: ModuleCache = {}\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)(\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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n\nconst moduleCache: ModuleCache = {}\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)(\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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;CAIC,GAED,oDAAoD,GAEpD,sEAAsE;AACtE,2DAA2D;AAE3D,SAASA;QAGJC;QACCC,sCAAAA,uCAAAA,yBAAAA;IAHJ,+CAA+C;IAC/C,OACE,CAAA,CAACD,+BAAAA,KAAKE,sBAAsB,AAGS,cAHpCF,0CAAAA,gCACCC,YAAAA,sBAAAA,iCAAAA,0BAAAA,UAAUE,aAAa,cAAvBF,+CAAAA,wCAAAA,wBACIG,YAAY,cADhBH,6DAAAA,uCAAAA,2CAAAA,yBACmB,oBADnBA,2DAAAA,qCAEII,OAAO,CAAC,oBAAoB,QAClC;AAEJ;AAUA,IAAIC;AAEJ;;CAEC,GACD,IAAMC,iBAA+C,IAAIC;AAExD,CAAC;IACAF,UAAU;QACFG,eAAN,SAAMA,cAAcC,SAAS,EAAEC,MAAM;;oBAC7BC,UAEAC,UAODC,2BAAAA,mBAAAA,gBAAAA,WAAAA,OAAMC,gBACHC,gBACAC,eAcDC,4BAAAA,oBAAAA,iBAAAA,YAAAA,QAAMC;;;;4BAzBPP,WAAWQ,oBAAoBV;4BAE/BG,WAAWQ,oBAAoBT;4BACrCC,SAASS,OAAO;4BAEhB,IAAIX,UAAU,MAAM;gCAClB;;;4BACF;4BAEKG,kCAAAA,2BAAAA;;gCAAL,IAAKA,YAAwBH,OAAOY,WAAW,uBAA1CT,6BAAAA,QAAAA,yBAAAA,iCAA4C;oCAAtCC,iBAAND;oCACGE,iBAAiBQ,aAAaT;oCAC9BE,gBAAgBG,oBAAoBJ;oCAE1C,iFAAiF;oCACjFK,oBAAoBJ;gCACtB;;gCANKH;gCAAAA;;;yCAAAA,6BAAAA;wCAAAA;;;wCAAAA;8CAAAA;;;;4BAQL,kFAAkF;4BAClF;;gCAAMW,QAAQC,GAAG,CACff,OAAOY,WAAW,CAACI,GAAG,CAAC,SAACZ;2CACtBa,iBAAiBlB,WAAWK;;;;4BAFhC;4BAMA,IAAIJ,OAAOkB,gBAAgB,CAACC,MAAM,GAAG,GAAG;gCACjCZ,mCAAAA,4BAAAA;;oCAAL,IAAKA,aAAkBP,OAAOkB,gBAAgB,uBAAzCX,8BAAAA,SAAAA,0BAAAA,kCAA2C;wCAArCC,WAAND;wCACHa,8BAA8BrB,WAAWS;oCAC3C;;oCAFKD;oCAAAA;;;6CAAAA,8BAAAA;4CAAAA;;;4CAAAA;kDAAAA;;;;4BAGP;;;;;;YACF;;QAEA;;;KAGC,GACDc,iBAAAA,SAAAA,gBAAgBC,UAAsB,EAAErB,QAAkB;YACxD,OAAOsB,YAAYD,YAAYrB;QACjC;QAEMuB,iBAAN,SAAMA,gBACJC,WAAuB,EACvBC,WAAuB,EACvBC,aAAwB,EACxBC,WAAqC,EACrCC,UAA+B;;oBAEzBC,KAEEC;;;;4BAFFD,MAAME,iBAAiBL;4BAER;;gCAAMM,YAAYC,oBAAoB,CACzDJ,KACAD;;;4BAFME,WAAa,cAAbA;4BAKR;;gCAAOA,SAASI,OAAO;;;;YACzB;;QAEMC,uBAAN,SAAMA,sBACJX,WAAuB,EACvBC,WAAuB,EACvBC,aAAwB,EACxBC,WAAqC;;oBAE/BE;;;;4BAAAA,MAAME,iBAAiBL;4BAEtB;;gCAAMM,YAAYI,gBAAgB,CAACP;;;4BAA1C;;gCAAO;;;;YACT;;IACF;IAEA,SAASpB,oBAAoBT,QAAkB;QAC7C,IAAIC,WAAWN,eAAe0C,GAAG,CAACrC;QAClC,IAAI,CAACC,UAAU;YACb,IAAIS;YACJ,IAAI4B;YACJ,IAAMC,UAAU,IAAI1B,QAAc,SAAC2B,cAAcC;gBAC/C/B,UAAU8B;gBACVF,SAASG;YACX;YACAxC,WAAW;gBACTyC,UAAU;gBACVC,gBAAgB;gBAChBJ,SAAAA;gBACA7B,SAAS;oBACPT,SAAUyC,QAAQ,GAAG;oBACrBhC;gBACF;gBACA4B,QAAQA;YACV;YACA3C,eAAeiD,GAAG,CAAC5C,UAAUC;QAC/B;QACA,OAAOA;IACT;IAEA;;;GAGC,GACD,SAASqB,YAAYD,UAAsB,EAAErB,QAAkB;QAC7D,IAAMC,WAAWQ,oBAAoBT;QACrC,IAAIC,SAAS0C,cAAc,EAAE;YAC3B,OAAO1C,SAASsC,OAAO;QACzB;QAEA,IAAIlB,eAAewB,WAAWC,OAAO,EAAE;YACrC,gFAAgF;YAChF,sBAAsB;YACtB7C,SAAS0C,cAAc,GAAG;YAE1B,IAAII,MAAM/C,WAAW;gBACnB,uEAAuE;gBACvE,oBAAoB;gBACpBC,SAASS,OAAO;YAClB;YAEA,8EAA8E;YAC9E,0EAA0E;YAC1E,uCAAuC;YAEvC,OAAOT,SAASsC,OAAO;QACzB;QAEA,IAAI,OAAOS,kBAAkB,YAAY;YACvC,wBAAwB;YACxB,IAAID,MAAM/C,WAAW;YACnB,SAAS;YACX,OAAO,IAAIiD,KAAKjD,WAAW;gBACzBkD,KAAKC,yBAAyB,CAAEC,IAAI,CAACpD;gBACrCgD,cAAchD;YAChB,OAAO;gBACL,MAAM,IAAIqD,MACR,CAAC,mCAAmC,EAAErD,SAAS,UAAU,CAAC;YAE9D;QACF,OAAO;YACL,gFAAgF;YAChF,IAAMsD,kBAAkBC,UAAUvD;YAElC,IAAI+C,MAAM/C,WAAW;gBACnB,IAAMwD,gBAAgBC,SAASC,gBAAgB,CAC7C,CAAC,2BAA2B,EAAE1D,SAAS,+BAA+B,EAAEA,SAAS,+BAA+B,EAAEsD,gBAAgB,+BAA+B,EAAEA,gBAAgB,GAAG,CAAC;gBAEzL,IAAIE,cAActC,MAAM,GAAG,GAAG;oBAC5B,uEAAuE;oBACvE,oBAAoB;oBACpBjB,SAASS,OAAO;gBAClB,OAAO;oBACL,IAAMiD,OAAOF,SAASG,aAAa,CAAC;oBACpCD,KAAKE,GAAG,GAAG;oBACXF,KAAKG,IAAI,GAAG9D;oBACZ2D,KAAKI,OAAO,GAAG;wBACb9D,SAASqC,MAAM;oBACjB;oBACAqB,KAAKK,MAAM,GAAG;wBACZ,uEAAuE;wBACvE,oBAAoB;wBACpB/D,SAASS,OAAO;oBAClB;oBACA,kDAAkD;oBAClD+C,SAASQ,IAAI,CAACC,WAAW,CAACP;gBAC5B;YACF,OAAO,IAAIV,KAAKjD,WAAW;gBACzB,IAAMmE,kBAAkBV,SAASC,gBAAgB,CAC/C,CAAC,YAAY,EAAE1D,SAAS,gBAAgB,EAAEA,SAAS,gBAAgB,EAAEsD,gBAAgB,gBAAgB,EAAEA,gBAAgB,GAAG,CAAC;gBAE7H,IAAIa,gBAAgBjD,MAAM,GAAG,GAAG;wBAGzBhB,kCAAAA,2BAAAA;;wBAFL,qEAAqE;wBACrE,kEAAkE;wBAClE,QAAKA,YAAgBkE,MAAMC,IAAI,CAACF,qCAA3BjE,SAAAA,6BAAAA,QAAAA,yBAAAA,iCAA6C;4BAA7CA,IAAMoE,SAANpE;4BACHoE,OAAOC,gBAAgB,CAAC,SAAS;gCAC/BtE,SAASqC,MAAM;4BACjB;wBACF;;wBAJKpC;wBAAAA;;;iCAAAA,6BAAAA;gCAAAA;;;gCAAAA;sCAAAA;;;;gBAKP,OAAO;oBACL,IAAMsE,UAASf,SAASG,aAAa,CAAC;oBACtCY,QAAOC,GAAG,GAAGzE;oBACb,yEAAyE;oBACzE,wEAAwE;oBACxE,eAAe;oBACfwE,QAAOT,OAAO,GAAG;wBACf9D,SAASqC,MAAM;oBACjB;oBACA,kDAAkD;oBAClDmB,SAASQ,IAAI,CAACC,WAAW,CAACM;gBAC5B;YACF,OAAO;gBACL,MAAM,IAAInB,MAAM,CAAC,mCAAmC,EAAErD,UAAU;YAClE;QACF;QAEAC,SAAS0C,cAAc,GAAG;QAC1B,OAAO1C,SAASsC,OAAO;IACzB;IAEA,SAASR,iBAAiBL,aAAwB;QAChD,OAAOgD,MAAMlE,oBAAoBkB;IACnC;AACF,CAAC","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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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/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 */ /// +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 */ /// +/// +// 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; +/// +/// +/// +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 */ /// +/// +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 */ /// +/// +/// +/// +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 `` 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 */ /// +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 */ /// +/// +// 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; +/// +/// +/// +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 */ /// +/// +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 */ /// +/// +/// +/// +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 `` 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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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_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/// \n\ntype EsmNamespaceObject = Record\n\n// @ts-ignore Defined in `dev-base.ts`\ndeclare function getOrInstantiateModuleFromParent(\n id: ModuleId,\n sourceModule: M\n): M\n\nconst REEXPORTED_OBJECTS = new WeakMap()\n\n/**\n * Constructs the `__turbopack_context__` object for a module.\n */\nfunction Context(\n this: TurbopackBaseContext,\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\n\ntype ModuleContextMap = Record\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\n\n keys(): ModuleId[]\n\n resolve(moduleId: string): ModuleId\n}\n\ntype GetOrInstantiateModuleFromParent = (\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\n) {\n if (!hasOwnProperty.call(obj, name)) Object.defineProperty(obj, name, options)\n}\n\nfunction getOverwrittenModule(\n moduleCache: ModuleCache,\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,\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[]\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,\n object: Record,\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,\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,\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, 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,\n id: ModuleId\n): Exclude {\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,\n moduleId: ModuleId\n): Promise {\n const loader = this.r(moduleId) as (\n importFunction: EsmImport\n ) => Promise\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,\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)\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(maybePromise: any): maybePromise is Promise {\n return (\n maybePromise != null &&\n typeof maybePromise === 'object' &&\n 'then' in maybePromise &&\n typeof maybePromise.then === 'function'\n )\n}\n\nfunction isAsyncModuleExt(obj: T): obj is AsyncModuleExt & T {\n return turbopackQueues in obj\n}\n\nfunction createPromise() {\n let resolve: (value: T | PromiseLike) => void\n let reject: (reason?: any) => void\n\n const promise = new Promise((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\n\ntype AsyncModuleExt = {\n [turbopackQueues]: (fn: (queue: AsyncQueue) => void) => void\n [turbopackExports]: Exports\n [turbopackError]?: any\n}\n\ntype AsyncModulePromise = Promise & 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,\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 = new Set()\n\n const { resolve, reject, promise: rawPromise } = createPromise()\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 = {}\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) => 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 = {\n new (module: Module, exports: Exports): TurbopackBaseContext\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/// \n/// \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 extends TurbopackBaseContext {\n R: ResolvePathFromModule\n}\n\nconst browserContextPrototype =\n Context.prototype as TurbopackBrowserBaseContext\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\n loadWebAssembly: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n ) => Promise\n loadWebAssemblyModule: (\n sourceType: SourceType,\n sourceData: SourceData,\n wasmChunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n ) => Promise\n}\n\ninterface DevRuntimeBackend {\n reloadChunk?: (chunkUrl: ChunkUrl) => Promise\n unloadChunk?: (chunkUrl: ChunkUrl) => void\n restart: () => void\n}\n\nconst moduleFactories: ModuleFactories = new Map()\ncontextPrototype.M = moduleFactories\n\nconst availableModules: Map | true> = new Map()\n\nconst availableModuleChunks: Map | 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,\n chunkData: ChunkData\n): Promise {\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 {\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\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 = 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,\n Promise | typeof loadedChunk\n>()\n// Do not make this async. React relies on referential equality of the returned Promise.\nfunction loadChunkByUrl(\n this: TurbopackBrowserBaseContext,\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 {\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 {\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,\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module,\n importsObj: WebAssembly.Imports\n): Promise {\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,\n chunkPath: ChunkPath,\n edgeModule: () => WebAssembly.Module\n): Promise {\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":["/// \n/// \n/// \n\ninterface TurbopackDevContext extends TurbopackBrowserBaseContext {\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 = 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 ``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\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 = 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> = new Map()\n/**\n * Map from a chunk path to all modules it contains.\n */\nconst chunkModulesMap: Map> = 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 = new Set()\n/**\n * Map from a chunk list to the chunk paths it contains.\n */\nconst chunkListChunksMap: Map> = new Map()\n/**\n * Map from a chunk path to the chunk lists it belongs to.\n */\nconst chunkChunkListsMap: Map> = 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 = new Map()\n/**\n * Maps module instances to their hot module state.\n */\nconst moduleHotState: Map = new Map()\n/**\n * Modules that call `module.hot.invalidate()` (while being updated).\n */\nconst queuedInvalidatedModules: Set = 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,\n modified: Map\n): {\n outdatedModules: Set\n newModuleFactories: Map\n} {\n const newModuleFactories = new Map()\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\n): Set {\n const outdatedModules = new Set()\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\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>,\n chunksDeletedModules: Map>\n): { disposedModules: Set } {\n for (const [chunkPath, addedModuleIds] of chunksAddedModules) {\n for (const moduleId of addedModuleIds) {\n addModuleToChunk(moduleId, chunkPath)\n }\n }\n\n const disposedModules: Set = 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,\n disposedModules: Iterable\n): { outdatedModuleParents: Map> } {\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,\n outdatedModuleParents: Map>,\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) {\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,\n disposedModules: Iterable,\n newModuleFactories: Map\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,\n updates: Record\n): {\n added: Map\n modified: Map\n deleted: Set\n chunksAdded: Map>\n chunksDeleted: Map>\n} {\n const chunksAdded = new Map()\n const chunksDeleted = new Map()\n const added: Map = new Map()\n const modified = new Map()\n const deleted: Set = 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\n }\n\nfunction getAffectedModuleEffects(moduleId: ModuleId): ModuleEffect {\n const outdatedModules: Set = 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/// \n/// \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\n}\n\nlet BACKEND: RuntimeBackend\n\n/**\n * Maps chunk paths to the corresponding resolver.\n */\nconst chunkResolvers: Map = 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 {\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 {\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((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/// \n/// \n/// \n/// \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((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 `` 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 */ /// +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 */ /// +/// +// 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; +/// +/// +/// +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 */ /// +/// +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 */ /// +/// +/// +/// +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 `` 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 */ /// +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 */ /// +/// +// 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; +/// +/// +/// +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 */ /// +/// +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 */ /// +/// +/// +/// +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 `` 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