.

node_modules/next/dist/shared/lib/router/routes/app.d.ts

@@ -0,0 +1,71 @@
+import { type SegmentParam } from '../utils/get-segment-param';
+import { type InterceptionMarker } from '../utils/interception-routes';
+export type RouteGroupAppRouteSegment = {
+    type: 'route-group';
+    name: string;
+    /**
+     * If present, this segment has an interception marker prefixing it.
+     */
+    interceptionMarker?: InterceptionMarker;
+};
+export type ParallelRouteAppRouteSegment = {
+    type: 'parallel-route';
+    name: string;
+    /**
+     * If present, this segment has an interception marker prefixing it.
+     */
+    interceptionMarker?: InterceptionMarker;
+};
+export type StaticAppRouteSegment = {
+    type: 'static';
+    name: string;
+    /**
+     * If present, this segment has an interception marker prefixing it.
+     */
+    interceptionMarker?: InterceptionMarker;
+};
+export type DynamicAppRouteSegment = {
+    type: 'dynamic';
+    name: string;
+    param: SegmentParam;
+    /**
+     * If present, this segment has an interception marker prefixing it.
+     */
+    interceptionMarker?: InterceptionMarker;
+};
+/**
+ * Represents a single segment in a route path.
+ * Can be either static (e.g., "blog") or dynamic (e.g., "[slug]").
+ */
+export type AppRouteSegment = StaticAppRouteSegment | DynamicAppRouteSegment | RouteGroupAppRouteSegment | ParallelRouteAppRouteSegment;
+export type NormalizedAppRouteSegment = StaticAppRouteSegment | DynamicAppRouteSegment;
+export declare function parseAppRouteSegment(segment: string): AppRouteSegment | null;
+export type AppRoute = {
+    normalized: boolean;
+    pathname: string;
+    segments: AppRouteSegment[];
+    dynamicSegments: DynamicAppRouteSegment[];
+    interceptionMarker: InterceptionMarker | undefined;
+    interceptingRoute: AppRoute | undefined;
+    interceptedRoute: AppRoute | undefined;
+};
+export type NormalizedAppRoute = Omit<AppRoute, 'normalized' | 'segments'> & {
+    normalized: true;
+    segments: NormalizedAppRouteSegment[];
+};
+export declare function isNormalizedAppRoute(route: InterceptionAppRoute): route is NormalizedInterceptionAppRoute;
+export type InterceptionAppRoute = Omit<AppRoute, 'interceptionMarker' | 'interceptingRoute' | 'interceptedRoute'> & {
+    interceptionMarker: InterceptionMarker;
+    interceptingRoute: AppRoute;
+    interceptedRoute: AppRoute;
+};
+export type NormalizedInterceptionAppRoute = Omit<InterceptionAppRoute, 'normalized' | 'segments' | 'interceptionMarker' | 'interceptingRoute' | 'interceptedRoute'> & {
+    normalized: true;
+    segments: NormalizedAppRouteSegment[];
+    interceptionMarker: InterceptionMarker;
+    interceptingRoute: NormalizedAppRoute;
+    interceptedRoute: NormalizedAppRoute;
+};
+export declare function isInterceptionAppRoute(route: NormalizedAppRoute): route is NormalizedInterceptionAppRoute;
+export declare function parseAppRoute(pathname: string, normalized: true): NormalizedAppRoute;
+export declare function parseAppRoute(pathname: string, normalized: false): AppRoute;

node_modules/next/dist/shared/lib/router/routes/app.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isInterceptionAppRoute: null,
+    isNormalizedAppRoute: null,
+    parseAppRoute: null,
+    parseAppRouteSegment: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isInterceptionAppRoute: function() {
+        return isInterceptionAppRoute;
+    },
+    isNormalizedAppRoute: function() {
+        return isNormalizedAppRoute;
+    },
+    parseAppRoute: function() {
+        return parseAppRoute;
+    },
+    parseAppRouteSegment: function() {
+        return parseAppRouteSegment;
+    }
+});
+const _invarianterror = require("../../invariant-error");
+const _getsegmentparam = require("../utils/get-segment-param");
+const _interceptionroutes = require("../utils/interception-routes");
+function parseAppRouteSegment(segment) {
+    if (segment === '') {
+        return null;
+    }
+    // Check if the segment starts with an interception marker
+    const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+    const param = (0, _getsegmentparam.getSegmentParam)(segment);
+    if (param) {
+        return {
+            type: 'dynamic',
+            name: segment,
+            param,
+            interceptionMarker
+        };
+    } else if (segment.startsWith('(') && segment.endsWith(')')) {
+        return {
+            type: 'route-group',
+            name: segment,
+            interceptionMarker
+        };
+    } else if (segment.startsWith('@')) {
+        return {
+            type: 'parallel-route',
+            name: segment,
+            interceptionMarker
+        };
+    } else {
+        return {
+            type: 'static',
+            name: segment,
+            interceptionMarker
+        };
+    }
+}
+function isNormalizedAppRoute(route) {
+    return route.normalized;
+}
+function isInterceptionAppRoute(route) {
+    return route.interceptionMarker !== undefined && route.interceptingRoute !== undefined && route.interceptedRoute !== undefined;
+}
+function parseAppRoute(pathname, normalized) {
+    const pathnameSegments = pathname.split('/').filter(Boolean);
+    // Build segments array with static and dynamic segments
+    const segments = [];
+    // Parse if this is an interception route.
+    let interceptionMarker;
+    let interceptingRoute;
+    let interceptedRoute;
+    for (const segment of pathnameSegments){
+        // Parse the segment into an AppSegment.
+        const appSegment = parseAppRouteSegment(segment);
+        if (!appSegment) {
+            continue;
+        }
+        if (normalized && (appSegment.type === 'route-group' || appSegment.type === 'parallel-route')) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group or parallel route segment.`), "__NEXT_ERROR_CODE", {
+                value: "E923",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        segments.push(appSegment);
+        if (appSegment.interceptionMarker) {
+            const parts = pathname.split(appSegment.interceptionMarker);
+            if (parts.length !== 2) {
+                throw Object.defineProperty(new Error(`Invalid interception route: ${pathname}`), "__NEXT_ERROR_CODE", {
+                    value: "E924",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            interceptingRoute = normalized ? parseAppRoute(parts[0], true) : parseAppRoute(parts[0], false);
+            interceptedRoute = normalized ? parseAppRoute(parts[1], true) : parseAppRoute(parts[1], false);
+            interceptionMarker = appSegment.interceptionMarker;
+        }
+    }
+    const dynamicSegments = segments.filter((segment)=>segment.type === 'dynamic');
+    return {
+        normalized,
+        pathname,
+        segments,
+        dynamicSegments,
+        interceptionMarker,
+        interceptingRoute,
+        interceptedRoute
+    };
+}
+
+//# sourceMappingURL=app.js.map