@vectorize-io/hindsight-control-plane 0.2.0 → 0.3.0

package/standalone/node_modules/next/dist/client/components/router-reducer/fill-cache-with-new-subtree-data.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    fillCacheWithNewSubTreeData: null,
-    fillCacheWithNewSubTreeDataButOnlyLoading: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    fillCacheWithNewSubTreeData: function() {
-        return fillCacheWithNewSubTreeData;
-    },
-    fillCacheWithNewSubTreeDataButOnlyLoading: function() {
-        return fillCacheWithNewSubTreeDataButOnlyLoading;
-    }
-});
-const _invalidatecachebyrouterstate = require("./invalidate-cache-by-router-state");
-const _filllazyitemstillleafwithhead = require("./fill-lazy-items-till-leaf-with-head");
-const _createroutercachekey = require("./create-router-cache-key");
-const _segment = require("../../../shared/lib/segment");
-/**
- * Common logic for filling cache with new sub tree data.
- */ function fillCacheHelper(navigatedAt, newCache, existingCache, flightData, fillLazyItems) {
-    const { segmentPath, seedData: cacheNodeSeedData, tree: treePatch, head } = flightData;
-    let newCacheNode = newCache;
-    let existingCacheNode = existingCache;
-    for(let i = 0; i < segmentPath.length; i += 2){
-        const parallelRouteKey = segmentPath[i];
-        const segment = segmentPath[i + 1];
-        // segmentPath is a repeating tuple of parallelRouteKey and segment
-        // we know we've hit the last entry we've reached our final pair
-        const isLastEntry = i === segmentPath.length - 2;
-        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
-        const existingChildSegmentMap = existingCacheNode.parallelRoutes.get(parallelRouteKey);
-        if (!existingChildSegmentMap) {
-            continue;
-        }
-        let childSegmentMap = newCacheNode.parallelRoutes.get(parallelRouteKey);
-        if (!childSegmentMap || childSegmentMap === existingChildSegmentMap) {
-            childSegmentMap = new Map(existingChildSegmentMap);
-            newCacheNode.parallelRoutes.set(parallelRouteKey, childSegmentMap);
-        }
-        const existingChildCacheNode = existingChildSegmentMap.get(cacheKey);
-        let childCacheNode = childSegmentMap.get(cacheKey);
-        if (isLastEntry) {
-            if (cacheNodeSeedData && (!childCacheNode || !childCacheNode.lazyData || childCacheNode === existingChildCacheNode)) {
-                const rsc = cacheNodeSeedData[0];
-                const loading = cacheNodeSeedData[2];
-                childCacheNode = {
-                    lazyData: null,
-                    // When `fillLazyItems` is false, we only want to fill the RSC data for the layout,
-                    // not the page segment.
-                    rsc: fillLazyItems || segment !== _segment.PAGE_SEGMENT_KEY ? rsc : null,
-                    prefetchRsc: null,
-                    head: null,
-                    prefetchHead: null,
-                    loading,
-                    parallelRoutes: fillLazyItems && existingChildCacheNode ? new Map(existingChildCacheNode.parallelRoutes) : new Map(),
-                    navigatedAt
-                };
-                if (existingChildCacheNode && fillLazyItems) {
-                    (0, _invalidatecachebyrouterstate.invalidateCacheByRouterState)(childCacheNode, existingChildCacheNode, treePatch);
-                }
-                if (fillLazyItems) {
-                    (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(navigatedAt, childCacheNode, existingChildCacheNode, treePatch, cacheNodeSeedData, head);
-                }
-                childSegmentMap.set(cacheKey, childCacheNode);
-            }
-            continue;
-        }
-        if (!childCacheNode || !existingChildCacheNode) {
-            continue;
-        }
-        if (childCacheNode === existingChildCacheNode) {
-            childCacheNode = {
-                lazyData: childCacheNode.lazyData,
-                rsc: childCacheNode.rsc,
-                prefetchRsc: childCacheNode.prefetchRsc,
-                head: childCacheNode.head,
-                prefetchHead: childCacheNode.prefetchHead,
-                parallelRoutes: new Map(childCacheNode.parallelRoutes),
-                loading: childCacheNode.loading
-            };
-            childSegmentMap.set(cacheKey, childCacheNode);
-        }
-        // Move deeper into the cache nodes
-        newCacheNode = childCacheNode;
-        existingCacheNode = existingChildCacheNode;
-    }
-}
-function fillCacheWithNewSubTreeData(navigatedAt, newCache, existingCache, flightData) {
-    fillCacheHelper(navigatedAt, newCache, existingCache, flightData, true);
-}
-function fillCacheWithNewSubTreeDataButOnlyLoading(navigatedAt, newCache, existingCache, flightData) {
-    fillCacheHelper(navigatedAt, newCache, existingCache, flightData, false);
-}
-
-if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
-  Object.defineProperty(exports.default, '__esModule', { value: true });
-  Object.assign(exports.default, exports);
-  module.exports = exports.default;
-}
-
-//# sourceMappingURL=fill-cache-with-new-subtree-data.js.map

package/standalone/node_modules/next/dist/client/components/router-reducer/fill-lazy-items-till-leaf-with-head.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "fillLazyItemsTillLeafWithHead", {
-    enumerable: true,
-    get: function() {
-        return fillLazyItemsTillLeafWithHead;
-    }
-});
-const _createroutercachekey = require("./create-router-cache-key");
-function fillLazyItemsTillLeafWithHead(navigatedAt, newCache, existingCache, routerState, cacheNodeSeedData, head) {
-    const isLastSegment = Object.keys(routerState[1]).length === 0;
-    if (isLastSegment) {
-        newCache.head = head;
-        return;
-    }
-    // Remove segment that we got data for so that it is filled in during rendering of rsc.
-    for(const key in routerState[1]){
-        const parallelRouteState = routerState[1][key];
-        const segmentForParallelRoute = parallelRouteState[0];
-        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segmentForParallelRoute);
-        // TODO: We should traverse the cacheNodeSeedData tree instead of the router
-        // state tree. Ideally, they would always be the same shape, but because of
-        // the loading.js pattern, cacheNodeSeedData sometimes only represents a
-        // partial tree. That's why this node is sometimes null. Once PPR lands,
-        // loading.js will no longer have special behavior and we can traverse the
-        // data tree instead.
-        //
-        // We should also consider merging the router state tree and the data tree
-        // in the response format, so that we don't have to send the keys twice.
-        // Then the client can convert them into separate representations.
-        const parallelSeedData = cacheNodeSeedData !== null && cacheNodeSeedData[1][key] !== undefined ? cacheNodeSeedData[1][key] : null;
-        if (existingCache) {
-            const existingParallelRoutesCacheNode = existingCache.parallelRoutes.get(key);
-            if (existingParallelRoutesCacheNode) {
-                let parallelRouteCacheNode = new Map(existingParallelRoutesCacheNode);
-                const existingCacheNode = parallelRouteCacheNode.get(cacheKey);
-                let newCacheNode;
-                if (parallelSeedData !== null) {
-                    // New data was sent from the server.
-                    const seedNode = parallelSeedData[0];
-                    const loading = parallelSeedData[2];
-                    newCacheNode = {
-                        lazyData: null,
-                        rsc: seedNode,
-                        // This is a PPR-only field. When PPR is enabled, we shouldn't hit
-                        // this path during a navigation, but until PPR is fully implemented
-                        // yet it's possible the existing node does have a non-null
-                        // `prefetchRsc`. As an incremental step, we'll just de-opt to the
-                        // old behavior — no PPR value.
-                        prefetchRsc: null,
-                        head: null,
-                        prefetchHead: null,
-                        loading,
-                        parallelRoutes: new Map(existingCacheNode?.parallelRoutes),
-                        navigatedAt
-                    };
-                } else {
-                    // No data available for this node. This will trigger a lazy fetch
-                    // during render.
-                    newCacheNode = {
-                        lazyData: null,
-                        rsc: null,
-                        prefetchRsc: null,
-                        head: null,
-                        prefetchHead: null,
-                        parallelRoutes: new Map(existingCacheNode?.parallelRoutes),
-                        loading: null,
-                        navigatedAt
-                    };
-                }
-                // Overrides the cache key with the new cache node.
-                parallelRouteCacheNode.set(cacheKey, newCacheNode);
-                // Traverse deeper to apply the head / fill lazy items till the head.
-                fillLazyItemsTillLeafWithHead(navigatedAt, newCacheNode, existingCacheNode, parallelRouteState, parallelSeedData ? parallelSeedData : null, head);
-                newCache.parallelRoutes.set(key, parallelRouteCacheNode);
-                continue;
-            }
-        }
-        let newCacheNode;
-        if (parallelSeedData !== null) {
-            // New data was sent from the server.
-            const seedNode = parallelSeedData[0];
-            const loading = parallelSeedData[2];
-            newCacheNode = {
-                lazyData: null,
-                rsc: seedNode,
-                prefetchRsc: null,
-                head: null,
-                prefetchHead: null,
-                parallelRoutes: new Map(),
-                loading,
-                navigatedAt
-            };
-        } else {
-            // No data available for this node. This will trigger a lazy fetch
-            // during render.
-            newCacheNode = {
-                lazyData: null,
-                rsc: null,
-                prefetchRsc: null,
-                head: null,
-                prefetchHead: null,
-                parallelRoutes: new Map(),
-                loading: null,
-                navigatedAt
-            };
-        }
-        const existingParallelRoutes = newCache.parallelRoutes.get(key);
-        if (existingParallelRoutes) {
-            existingParallelRoutes.set(cacheKey, newCacheNode);
-        } else {
-            newCache.parallelRoutes.set(key, new Map([
-                [
-                    cacheKey,
-                    newCacheNode
-                ]
-            ]));
-        }
-        fillLazyItemsTillLeafWithHead(navigatedAt, newCacheNode, undefined, parallelRouteState, parallelSeedData, head);
-    }
-}
-
-if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
-  Object.defineProperty(exports.default, '__esModule', { value: true });
-  Object.assign(exports.default, exports);
-  module.exports = exports.default;
-}
-
-//# sourceMappingURL=fill-lazy-items-till-leaf-with-head.js.map

package/standalone/node_modules/next/dist/client/components/router-reducer/handle-segment-mismatch.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "handleSegmentMismatch", {
-    enumerable: true,
-    get: function() {
-        return handleSegmentMismatch;
-    }
-});
-const _navigatereducer = require("./reducers/navigate-reducer");
-function handleSegmentMismatch(state, action, treePatch) {
-    if (process.env.NODE_ENV === 'development') {
-        console.warn('Performing hard navigation because your application experienced an unrecoverable error. If this keeps occurring, please file a Next.js issue.\n\n' + 'Reason: Segment mismatch\n' + `Last Action: ${action.type}\n\n` + `Current Tree: ${JSON.stringify(state.tree)}\n\n` + `Tree Patch Payload: ${JSON.stringify(treePatch)}`);
-    }
-    return (0, _navigatereducer.handleExternalUrl)(state, {}, state.canonicalUrl, true);
-}
-
-if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
-  Object.defineProperty(exports.default, '__esModule', { value: true });
-  Object.assign(exports.default, exports);
-  module.exports = exports.default;
-}
-
-//# sourceMappingURL=handle-segment-mismatch.js.map

package/standalone/node_modules/next/dist/client/components/router-reducer/invalidate-cache-by-router-state.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "invalidateCacheByRouterState", {
-    enumerable: true,
-    get: function() {
-        return invalidateCacheByRouterState;
-    }
-});
-const _createroutercachekey = require("./create-router-cache-key");
-function invalidateCacheByRouterState(newCache, existingCache, routerState) {
-    // Remove segment that we got data for so that it is filled in during rendering of rsc.
-    for(const key in routerState[1]){
-        const segmentForParallelRoute = routerState[1][key][0];
-        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segmentForParallelRoute);
-        const existingParallelRoutesCacheNode = existingCache.parallelRoutes.get(key);
-        if (existingParallelRoutesCacheNode) {
-            let parallelRouteCacheNode = new Map(existingParallelRoutesCacheNode);
-            parallelRouteCacheNode.delete(cacheKey);
-            newCache.parallelRoutes.set(key, parallelRouteCacheNode);
-        }
-    }
-}
-
-if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
-  Object.defineProperty(exports.default, '__esModule', { value: true });
-  Object.assign(exports.default, exports);
-  module.exports = exports.default;
-}
-
-//# sourceMappingURL=invalidate-cache-by-router-state.js.map

package/standalone/node_modules/next/dist/client/components/router-reducer/refetch-inactive-parallel-segments.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    addRefreshMarkerToActiveParallelSegments: null,
-    refreshInactiveParallelSegments: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    addRefreshMarkerToActiveParallelSegments: function() {
-        return addRefreshMarkerToActiveParallelSegments;
-    },
-    refreshInactiveParallelSegments: function() {
-        return refreshInactiveParallelSegments;
-    }
-});
-const _applyflightdata = require("./apply-flight-data");
-const _fetchserverresponse = require("./fetch-server-response");
-const _segment = require("../../../shared/lib/segment");
-async function refreshInactiveParallelSegments(options) {
-    const fetchedSegments = new Set();
-    await refreshInactiveParallelSegmentsImpl({
-        ...options,
-        rootTree: options.updatedTree,
-        fetchedSegments
-    });
-}
-async function refreshInactiveParallelSegmentsImpl({ navigatedAt, state, updatedTree, updatedCache, includeNextUrl, fetchedSegments, rootTree = updatedTree, canonicalUrl }) {
-    const [, parallelRoutes, refetchPath, refetchMarker] = updatedTree;
-    const fetchPromises = [];
-    if (refetchPath && refetchPath !== canonicalUrl && refetchMarker === 'refresh' && // it's possible for the tree to contain multiple segments that contain data at the same URL
-    // we keep track of them so we can dedupe the requests
-    !fetchedSegments.has(refetchPath)) {
-        fetchedSegments.add(refetchPath) // Mark this URL as fetched
-        ;
-        // Eagerly kick off the fetch for the refetch path & the parallel routes. This should be fine to do as they each operate
-        // independently on their own cache nodes, and `applyFlightData` will copy anything it doesn't care about from the existing cache.
-        const fetchPromise = (0, _fetchserverresponse.fetchServerResponse)(new URL(refetchPath, location.origin), {
-            // refetch from the root of the updated tree, otherwise it will be scoped to the current segment
-            // and might not contain the data we need to patch in interception route data (such as dynamic params from a previous segment)
-            flightRouterState: [
-                rootTree[0],
-                rootTree[1],
-                rootTree[2],
-                'refetch'
-            ],
-            nextUrl: includeNextUrl ? state.nextUrl : null
-        }).then((result)=>{
-            if (typeof result !== 'string') {
-                const { flightData } = result;
-                for (const flightDataPath of flightData){
-                    // we only pass the new cache as this function is called after clearing the router cache
-                    // and filling in the new page data from the server. Meaning the existing cache is actually the cache that's
-                    // just been created & has been written to, but hasn't been "committed" yet.
-                    (0, _applyflightdata.applyFlightData)(navigatedAt, updatedCache, updatedCache, flightDataPath);
-                }
-            } else {
-            // When result is a string, it suggests that the server response should have triggered an MPA navigation
-            // I'm not 100% sure of this decision, but it seems unlikely that we'd want to introduce a redirect side effect
-            // when refreshing on-screen data, so handling this has been ommitted.
-            }
-        });
-        fetchPromises.push(fetchPromise);
-    }
-    for(const key in parallelRoutes){
-        const parallelFetchPromise = refreshInactiveParallelSegmentsImpl({
-            navigatedAt,
-            state,
-            updatedTree: parallelRoutes[key],
-            updatedCache,
-            includeNextUrl,
-            fetchedSegments,
-            rootTree,
-            canonicalUrl
-        });
-        fetchPromises.push(parallelFetchPromise);
-    }
-    await Promise.all(fetchPromises);
-}
-function addRefreshMarkerToActiveParallelSegments(tree, path) {
-    const [segment, parallelRoutes, , refetchMarker] = tree;
-    // a page segment might also contain concatenated search params, so we do a partial match on the key
-    if (segment.includes(_segment.PAGE_SEGMENT_KEY) && refetchMarker !== 'refresh') {
-        tree[2] = path;
-        tree[3] = 'refresh';
-    }
-    for(const key in parallelRoutes){
-        addRefreshMarkerToActiveParallelSegments(parallelRoutes[key], path);
-    }
-}
-
-if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
-  Object.defineProperty(exports.default, '__esModule', { value: true });
-  Object.assign(exports.default, exports);
-  module.exports = exports.default;
-}
-
-//# sourceMappingURL=refetch-inactive-parallel-segments.js.map

package/standalone/node_modules/next/dist/lib/server-external-packages.json

@@ -1,75 +0,0 @@
-[
-  "@appsignal/nodejs",
-  "@aws-sdk/client-s3",
-  "@aws-sdk/s3-presigned-post",
-  "@blockfrost/blockfrost-js",
-  "@highlight-run/node",
-  "@huggingface/transformers",
-  "@jpg-store/lucid-cardano",
-  "@libsql/client",
-  "@mikro-orm/core",
-  "@mikro-orm/knex",
-  "@node-rs/argon2",
-  "@node-rs/bcrypt",
-  "@prisma/client",
-  "@react-pdf/renderer",
-  "@sentry/profiling-node",
-  "@sparticuz/chromium",
-  "@sparticuz/chromium-min",
-  "@statsig/statsig-node-core",
-  "@swc/core",
-  "@xenova/transformers",
-  "argon2",
-  "autoprefixer",
-  "aws-crt",
-  "bcrypt",
-  "better-sqlite3",
-  "canvas",
-  "chromadb-default-embed",
-  "config",
-  "cpu-features",
-  "cypress",
-  "dd-trace",
-  "eslint",
-  "express",
-  "firebase-admin",
-  "htmlrewriter",
-  "import-in-the-middle",
-  "isolated-vm",
-  "jest",
-  "jsdom",
-  "keyv",
-  "libsql",
-  "mdx-bundler",
-  "mongodb",
-  "mongoose",
-  "newrelic",
-  "next-mdx-remote",
-  "next-seo",
-  "node-cron",
-  "node-pty",
-  "node-web-audio-api",
-  "onnxruntime-node",
-  "oslo",
-  "pg",
-  "playwright",
-  "playwright-core",
-  "postcss",
-  "prettier",
-  "prisma",
-  "puppeteer",
-  "puppeteer-core",
-  "ravendb",
-  "require-in-the-middle",
-  "rimraf",
-  "sharp",
-  "shiki",
-  "sqlite3",
-  "ts-node",
-  "ts-morph",
-  "typescript",
-  "vscode-oniguruma",
-  "webpack",
-  "websocket",
-  "zeromq"
-]

package/standalone/node_modules/next/dist/server/app-render/action-utils.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    createServerModuleMap: null,
-    selectWorkerForForwarding: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createServerModuleMap: function() {
-        return createServerModuleMap;
-    },
-    selectWorkerForForwarding: function() {
-        return selectWorkerForForwarding;
-    }
-});
-const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
-const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
-const _workasyncstorageexternal = require("./work-async-storage.external");
-function createServerModuleMap({ serverActionsManifest }) {
-    return new Proxy({}, {
-        get: (_, id)=>{
-            var _serverActionsManifest__id, _serverActionsManifest_;
-            const workers = (_serverActionsManifest_ = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_serverActionsManifest__id = _serverActionsManifest_[id]) == null ? void 0 : _serverActionsManifest__id.workers;
-            if (!workers) {
-                return undefined;
-            }
-            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-            let workerEntry;
-            if (workStore) {
-                workerEntry = workers[normalizeWorkerPageName(workStore.page)];
-            } else {
-                // If there's no work store defined, we can assume that a server
-                // module map is needed during module evaluation, e.g. to create a
-                // server action using a higher-order function. Therefore it should be
-                // safe to return any entry from the manifest that matches the action
-                // ID. They all refer to the same module ID, which must also exist in
-                // the current page bundle. TODO: This is currently not guaranteed in
-                // Turbopack, and needs to be fixed.
-                workerEntry = Object.values(workers).at(0);
-            }
-            if (!workerEntry) {
-                return undefined;
-            }
-            const { moduleId, async } = workerEntry;
-            return {
-                id: moduleId,
-                name: id,
-                chunks: [],
-                async
-            };
-        }
-    });
-}
-function selectWorkerForForwarding(actionId, pageName, serverActionsManifest) {
-    var _serverActionsManifest__actionId;
-    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
-    const workerName = normalizeWorkerPageName(pageName);
-    // no workers, nothing to forward to
-    if (!workers) return;
-    // if there is a worker for this page, no need to forward it.
-    if (workers[workerName]) {
-        return;
-    }
-    // otherwise, grab the first worker that has a handler for this action id
-    return denormalizeWorkerPageName(Object.keys(workers)[0]);
-}
-/**
- * The flight entry loader keys actions by bundlePath.
- * bundlePath corresponds with the relative path (including 'app') to the page entrypoint.
- */ function normalizeWorkerPageName(pageName) {
-    if ((0, _pathhasprefix.pathHasPrefix)(pageName, 'app')) {
-        return pageName;
-    }
-    return 'app' + pageName;
-}
-/**
- * Converts a bundlePath (relative path to the entrypoint) to a routable page name
- */ function denormalizeWorkerPageName(bundlePath) {
-    return (0, _apppaths.normalizeAppPath)((0, _removepathprefix.removePathPrefix)(bundlePath, 'app'));
-}
-
-//# sourceMappingURL=action-utils.js.map

package/standalone/node_modules/next/dist/server/normalizers/request/prefetch-rsc.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "PrefetchRSCPathnameNormalizer", {
-    enumerable: true,
-    get: function() {
-        return PrefetchRSCPathnameNormalizer;
-    }
-});
-const _constants = require("../../../lib/constants");
-const _suffix = require("./suffix");
-class PrefetchRSCPathnameNormalizer extends _suffix.SuffixPathnameNormalizer {
-    constructor(){
-        super(_constants.RSC_PREFETCH_SUFFIX);
-    }
-    match(pathname) {
-        if (pathname === '/__index' + _constants.RSC_PREFETCH_SUFFIX) {
-            return true;
-        }
-        return super.match(pathname);
-    }
-    normalize(pathname, matched) {
-        if (pathname === '/__index' + _constants.RSC_PREFETCH_SUFFIX) {
-            return '/';
-        }
-        return super.normalize(pathname, matched);
-    }
-}
-
-//# sourceMappingURL=prefetch-rsc.js.map