failproofai 0.0.1-beta.1

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/route-regex.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getNamedMiddlewareRegex: null,
+    getNamedRouteRegex: null,
+    getRouteRegex: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getNamedMiddlewareRegex: function() {
+        return getNamedMiddlewareRegex;
+    },
+    getNamedRouteRegex: function() {
+        return getNamedRouteRegex;
+    },
+    getRouteRegex: function() {
+        return getRouteRegex;
+    }
+});
+const _constants = require("../../../../lib/constants");
+const _interceptionroutes = require("./interception-routes");
+const _escaperegexp = require("../../escape-regexp");
+const _removetrailingslash = require("./remove-trailing-slash");
+const _getdynamicparam = require("./get-dynamic-param");
+function getParametrizedRoute(route, includeSuffix, includePrefix) {
+    const groups = {};
+    let groupIndex = 1;
+    const segments = [];
+    for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split('/')){
+        const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+        const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN) // Check for parameters
+        ;
+        if (markerMatch && paramMatches && paramMatches[2]) {
+            const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+            groups[key] = {
+                pos: groupIndex++,
+                repeat,
+                optional
+            };
+            segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(markerMatch)}([^/]+?)`);
+        } else if (paramMatches && paramMatches[2]) {
+            const { key, repeat, optional } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+            groups[key] = {
+                pos: groupIndex++,
+                repeat,
+                optional
+            };
+            if (includePrefix && paramMatches[1]) {
+                segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(paramMatches[1])}`);
+            }
+            let s = repeat ? optional ? '(?:/(.+?))?' : '/(.+?)' : '/([^/]+?)';
+            // Remove the leading slash if includePrefix already added it.
+            if (includePrefix && paramMatches[1]) {
+                s = s.substring(1);
+            }
+            segments.push(s);
+        } else {
+            segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(segment)}`);
+        }
+        // If there's a suffix, add it to the segments if it's enabled.
+        if (includeSuffix && paramMatches && paramMatches[3]) {
+            segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+        }
+    }
+    return {
+        parameterizedRoute: segments.join(''),
+        groups
+    };
+}
+function getRouteRegex(normalizedRoute, { includeSuffix = false, includePrefix = false, excludeOptionalTrailingSlash = false } = {}) {
+    const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute, includeSuffix, includePrefix);
+    let re = parameterizedRoute;
+    if (!excludeOptionalTrailingSlash) {
+        re += '(?:/)?';
+    }
+    return {
+        re: new RegExp(`^${re}$`),
+        groups: groups
+    };
+}
+/**
+ * Builds a function to generate a minimal routeKey using only a-z and minimal
+ * number of characters.
+ */ function buildGetSafeRouteKey() {
+    let i = 0;
+    return ()=>{
+        let routeKey = '';
+        let j = ++i;
+        while(j > 0){
+            routeKey += String.fromCharCode(97 + (j - 1) % 26);
+            j = Math.floor((j - 1) / 26);
+        }
+        return routeKey;
+    };
+}
+function getSafeKeyFromSegment({ interceptionMarker, getSafeRouteKey, segment, routeKeys, keyPrefix, backreferenceDuplicateKeys }) {
+    const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(segment);
+    // replace any non-word characters since they can break
+    // the named regex
+    let cleanedKey = key.replace(/\W/g, '');
+    if (keyPrefix) {
+        cleanedKey = `${keyPrefix}${cleanedKey}`;
+    }
+    let invalidKey = false;
+    // check if the key is still invalid and fallback to using a known
+    // safe key
+    if (cleanedKey.length === 0 || cleanedKey.length > 30) {
+        invalidKey = true;
+    }
+    if (!isNaN(parseInt(cleanedKey.slice(0, 1)))) {
+        invalidKey = true;
+    }
+    if (invalidKey) {
+        cleanedKey = getSafeRouteKey();
+    }
+    const duplicateKey = cleanedKey in routeKeys;
+    if (keyPrefix) {
+        routeKeys[cleanedKey] = `${keyPrefix}${key}`;
+    } else {
+        routeKeys[cleanedKey] = key;
+    }
+    // if the segment has an interception marker, make sure that's part of the regex pattern
+    // this is to ensure that the route with the interception marker doesn't incorrectly match
+    // the non-intercepted route (ie /app/(.)[username] should not match /app/[username])
+    const interceptionPrefix = interceptionMarker ? (0, _escaperegexp.escapeStringRegexp)(interceptionMarker) : '';
+    let pattern;
+    if (duplicateKey && backreferenceDuplicateKeys) {
+        // Use a backreference to the key to ensure that the key is the same value
+        // in each of the placeholders.
+        pattern = `\\k<${cleanedKey}>`;
+    } else if (repeat) {
+        pattern = `(?<${cleanedKey}>.+?)`;
+    } else {
+        pattern = `(?<${cleanedKey}>[^/]+?)`;
+    }
+    return {
+        key,
+        pattern: optional ? `(?:/${interceptionPrefix}${pattern})?` : `/${interceptionPrefix}${pattern}`,
+        cleanedKey: cleanedKey,
+        optional,
+        repeat
+    };
+}
+function getNamedParametrizedRoute(route, prefixRouteKeys, includeSuffix, includePrefix, backreferenceDuplicateKeys, reference = {
+    names: {},
+    intercepted: {}
+}) {
+    const getSafeRouteKey = buildGetSafeRouteKey();
+    const routeKeys = {};
+    const segments = [];
+    const inverseParts = [];
+    // Ensure we don't mutate the original reference object.
+    reference = structuredClone(reference);
+    for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split('/')){
+        const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>segment.startsWith(m));
+        const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN) // Check for parameters
+        ;
+        const interceptionMarker = hasInterceptionMarker ? paramMatches?.[1] : undefined;
+        let keyPrefix;
+        if (interceptionMarker && paramMatches?.[2]) {
+            keyPrefix = prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : undefined;
+            reference.intercepted[paramMatches[2]] = interceptionMarker;
+        } else if (paramMatches?.[2] && reference.intercepted[paramMatches[2]]) {
+            keyPrefix = prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : undefined;
+        } else {
+            keyPrefix = prefixRouteKeys ? _constants.NEXT_QUERY_PARAM_PREFIX : undefined;
+        }
+        if (interceptionMarker && paramMatches && paramMatches[2]) {
+            // If there's an interception marker, add it to the segments.
+            const { key, pattern, cleanedKey, repeat, optional } = getSafeKeyFromSegment({
+                getSafeRouteKey,
+                interceptionMarker,
+                segment: paramMatches[2],
+                routeKeys,
+                keyPrefix,
+                backreferenceDuplicateKeys
+            });
+            segments.push(pattern);
+            inverseParts.push(`/${paramMatches[1]}:${reference.names[key] ?? cleanedKey}${repeat ? optional ? '*' : '+' : ''}`);
+            reference.names[key] ??= cleanedKey;
+        } else if (paramMatches && paramMatches[2]) {
+            // If there's a prefix, add it to the segments if it's enabled.
+            if (includePrefix && paramMatches[1]) {
+                segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(paramMatches[1])}`);
+                inverseParts.push(`/${paramMatches[1]}`);
+            }
+            const { key, pattern, cleanedKey, repeat, optional } = getSafeKeyFromSegment({
+                getSafeRouteKey,
+                segment: paramMatches[2],
+                routeKeys,
+                keyPrefix,
+                backreferenceDuplicateKeys
+            });
+            // Remove the leading slash if includePrefix already added it.
+            let s = pattern;
+            if (includePrefix && paramMatches[1]) {
+                s = s.substring(1);
+            }
+            segments.push(s);
+            inverseParts.push(`/:${reference.names[key] ?? cleanedKey}${repeat ? optional ? '*' : '+' : ''}`);
+            reference.names[key] ??= cleanedKey;
+        } else {
+            segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(segment)}`);
+            inverseParts.push(`/${segment}`);
+        }
+        // If there's a suffix, add it to the segments if it's enabled.
+        if (includeSuffix && paramMatches && paramMatches[3]) {
+            segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+            inverseParts.push(paramMatches[3]);
+        }
+    }
+    return {
+        namedParameterizedRoute: segments.join(''),
+        routeKeys,
+        pathToRegexpPattern: inverseParts.join(''),
+        reference
+    };
+}
+function getNamedRouteRegex(normalizedRoute, options) {
+    const result = getNamedParametrizedRoute(normalizedRoute, options.prefixRouteKeys, options.includeSuffix ?? false, options.includePrefix ?? false, options.backreferenceDuplicateKeys ?? false, options.reference);
+    let namedRegex = result.namedParameterizedRoute;
+    if (!options.excludeOptionalTrailingSlash) {
+        namedRegex += '(?:/)?';
+    }
+    return {
+        ...getRouteRegex(normalizedRoute, options),
+        namedRegex: `^${namedRegex}$`,
+        routeKeys: result.routeKeys,
+        pathToRegexpPattern: result.pathToRegexpPattern,
+        reference: result.reference
+    };
+}
+function getNamedMiddlewareRegex(normalizedRoute, options) {
+    const { parameterizedRoute } = getParametrizedRoute(normalizedRoute, false, false);
+    const { catchAll = true } = options;
+    if (parameterizedRoute === '/') {
+        let catchAllRegex = catchAll ? '.*' : '';
+        return {
+            namedRegex: `^/${catchAllRegex}$`
+        };
+    }
+    const { namedParameterizedRoute } = getNamedParametrizedRoute(normalizedRoute, false, false, false, false, undefined);
+    let catchAllGroupedRegex = catchAll ? '(?:(/.*)?)' : '';
+    return {
+        namedRegex: `^${namedParameterizedRoute}${catchAllGroupedRegex}$`
+    };
+}
+
+//# sourceMappingURL=route-regex.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/sorted-routes.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSortedRouteObjects: null,
+    getSortedRoutes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getSortedRouteObjects: function() {
+        return getSortedRouteObjects;
+    },
+    getSortedRoutes: function() {
+        return getSortedRoutes;
+    }
+});
+class UrlNode {
+    insert(urlPath) {
+        this._insert(urlPath.split('/').filter(Boolean), [], false);
+    }
+    smoosh() {
+        return this._smoosh();
+    }
+    _smoosh(prefix = '/') {
+        const childrenPaths = [
+            ...this.children.keys()
+        ].sort();
+        if (this.slugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[]'), 1);
+        }
+        if (this.restSlugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[...]'), 1);
+        }
+        if (this.optionalRestSlugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[[...]]'), 1);
+        }
+        const routes = childrenPaths.map((c)=>this.children.get(c)._smoosh(`${prefix}${c}/`)).reduce((prev, curr)=>[
+                ...prev,
+                ...curr
+            ], []);
+        if (this.slugName !== null) {
+            routes.push(...this.children.get('[]')._smoosh(`${prefix}[${this.slugName}]/`));
+        }
+        if (!this.placeholder) {
+            const r = prefix === '/' ? '/' : prefix.slice(0, -1);
+            if (this.optionalRestSlugName != null) {
+                throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${r}" and "${r}[[...${this.optionalRestSlugName}]]").`), "__NEXT_ERROR_CODE", {
+                    value: "E458",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            routes.unshift(r);
+        }
+        if (this.restSlugName !== null) {
+            routes.push(...this.children.get('[...]')._smoosh(`${prefix}[...${this.restSlugName}]/`));
+        }
+        if (this.optionalRestSlugName !== null) {
+            routes.push(...this.children.get('[[...]]')._smoosh(`${prefix}[[...${this.optionalRestSlugName}]]/`));
+        }
+        return routes;
+    }
+    _insert(urlPaths, slugNames, isCatchAll) {
+        if (urlPaths.length === 0) {
+            this.placeholder = false;
+            return;
+        }
+        if (isCatchAll) {
+            throw Object.defineProperty(new Error(`Catch-all must be the last part of the URL.`), "__NEXT_ERROR_CODE", {
+                value: "E392",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // The next segment in the urlPaths list
+        let nextSegment = urlPaths[0];
+        // Check if the segment matches `[something]`
+        if (nextSegment.startsWith('[') && nextSegment.endsWith(']')) {
+            // Strip `[` and `]`, leaving only `something`
+            let segmentName = nextSegment.slice(1, -1);
+            let isOptional = false;
+            if (segmentName.startsWith('[') && segmentName.endsWith(']')) {
+                // Strip optional `[` and `]`, leaving only `something`
+                segmentName = segmentName.slice(1, -1);
+                isOptional = true;
+            }
+            if (segmentName.startsWith('…')) {
+                throw Object.defineProperty(new Error(`Detected a three-dot character ('…') at ('${segmentName}'). Did you mean ('...')?`), "__NEXT_ERROR_CODE", {
+                    value: "E147",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            if (segmentName.startsWith('...')) {
+                // Strip `...`, leaving only `something`
+                segmentName = segmentName.substring(3);
+                isCatchAll = true;
+            }
+            if (segmentName.startsWith('[') || segmentName.endsWith(']')) {
+                throw Object.defineProperty(new Error(`Segment names may not start or end with extra brackets ('${segmentName}').`), "__NEXT_ERROR_CODE", {
+                    value: "E421",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            if (segmentName.startsWith('.')) {
+                throw Object.defineProperty(new Error(`Segment names may not start with erroneous periods ('${segmentName}').`), "__NEXT_ERROR_CODE", {
+                    value: "E288",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            function handleSlug(previousSlug, nextSlug) {
+                if (previousSlug !== null) {
+                    // If the specific segment already has a slug but the slug is not `something`
+                    // This prevents collisions like:
+                    // pages/[post]/index.js
+                    // pages/[id]/index.js
+                    // Because currently multiple dynamic params on the same segment level are not supported
+                    if (previousSlug !== nextSlug) {
+                        // TODO: This error seems to be confusing for users, needs an error link, the description can be based on above comment.
+                        throw Object.defineProperty(new Error(`You cannot use different slug names for the same dynamic path ('${previousSlug}' !== '${nextSlug}').`), "__NEXT_ERROR_CODE", {
+                            value: "E337",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                }
+                slugNames.forEach((slug)=>{
+                    if (slug === nextSlug) {
+                        throw Object.defineProperty(new Error(`You cannot have the same slug name "${nextSlug}" repeat within a single dynamic path`), "__NEXT_ERROR_CODE", {
+                            value: "E247",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    if (slug.replace(/\W/g, '') === nextSegment.replace(/\W/g, '')) {
+                        throw Object.defineProperty(new Error(`You cannot have the slug names "${slug}" and "${nextSlug}" differ only by non-word symbols within a single dynamic path`), "__NEXT_ERROR_CODE", {
+                            value: "E499",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                });
+                slugNames.push(nextSlug);
+            }
+            if (isCatchAll) {
+                if (isOptional) {
+                    if (this.restSlugName != null) {
+                        throw Object.defineProperty(new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`), "__NEXT_ERROR_CODE", {
+                            value: "E299",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    handleSlug(this.optionalRestSlugName, segmentName);
+                    // slugName is kept as it can only be one particular slugName
+                    this.optionalRestSlugName = segmentName;
+                    // nextSegment is overwritten to [[...]] so that it can later be sorted specifically
+                    nextSegment = '[[...]]';
+                } else {
+                    if (this.optionalRestSlugName != null) {
+                        throw Object.defineProperty(new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
+                            value: "E300",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    handleSlug(this.restSlugName, segmentName);
+                    // slugName is kept as it can only be one particular slugName
+                    this.restSlugName = segmentName;
+                    // nextSegment is overwritten to [...] so that it can later be sorted specifically
+                    nextSegment = '[...]';
+                }
+            } else {
+                if (isOptional) {
+                    throw Object.defineProperty(new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
+                        value: "E435",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                handleSlug(this.slugName, segmentName);
+                // slugName is kept as it can only be one particular slugName
+                this.slugName = segmentName;
+                // nextSegment is overwritten to [] so that it can later be sorted specifically
+                nextSegment = '[]';
+            }
+        }
+        // If this UrlNode doesn't have the nextSegment yet we create a new child UrlNode
+        if (!this.children.has(nextSegment)) {
+            this.children.set(nextSegment, new UrlNode());
+        }
+        this.children.get(nextSegment)._insert(urlPaths.slice(1), slugNames, isCatchAll);
+    }
+    constructor(){
+        this.placeholder = true;
+        this.children = new Map();
+        this.slugName = null;
+        this.restSlugName = null;
+        this.optionalRestSlugName = null;
+    }
+}
+function getSortedRoutes(normalizedPages) {
+    // First the UrlNode is created, and every UrlNode can have only 1 dynamic segment
+    // Eg you can't have pages/[post]/abc.js and pages/[hello]/something-else.js
+    // Only 1 dynamic segment per nesting level
+    // So in the case that is test/integration/dynamic-routing it'll be this:
+    // pages/[post]/comments.js
+    // pages/blog/[post]/comment/[id].js
+    // Both are fine because `pages/[post]` and `pages/blog` are on the same level
+    // So in this case `UrlNode` created here has `this.slugName === 'post'`
+    // And since your PR passed through `slugName` as an array basically it'd including it in too many possibilities
+    // Instead what has to be passed through is the upwards path's dynamic names
+    const root = new UrlNode();
+    // Here the `root` gets injected multiple paths, and insert will break them up into sublevels
+    normalizedPages.forEach((pagePath)=>root.insert(pagePath));
+    // Smoosh will then sort those sublevels up to the point where you get the correct route definition priority
+    return root.smoosh();
+}
+function getSortedRouteObjects(objects, getter) {
+    // We're assuming here that all the pathnames are unique, that way we can
+    // sort the list and use the index as the key.
+    const indexes = {};
+    const pathnames = [];
+    for(let i = 0; i < objects.length; i++){
+        const pathname = getter(objects[i]);
+        indexes[pathname] = i;
+        pathnames[i] = pathname;
+    }
+    // Sort the pathnames.
+    const sorted = getSortedRoutes(pathnames);
+    // Map the sorted pathnames back to the original objects using the new sorted
+    // index.
+    return sorted.map((pathname)=>objects[indexes[pathname]]);
+}
+
+//# sourceMappingURL=sorted-routes.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/router-context.shared-runtime.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RouterContext", {
+    enumerable: true,
+    get: function() {
+        return RouterContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const RouterContext = _react.default.createContext(null);
+if (process.env.NODE_ENV !== 'production') {
+    RouterContext.displayName = 'RouterContext';
+}
+
+//# sourceMappingURL=router-context.shared-runtime.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HEAD_REQUEST_KEY: null,
+    ROOT_SEGMENT_REQUEST_KEY: null,
+    appendSegmentRequestKeyPart: null,
+    convertSegmentPathToStaticExportFilename: null,
+    createSegmentRequestKeyPart: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HEAD_REQUEST_KEY: function() {
+        return HEAD_REQUEST_KEY;
+    },
+    ROOT_SEGMENT_REQUEST_KEY: function() {
+        return ROOT_SEGMENT_REQUEST_KEY;
+    },
+    appendSegmentRequestKeyPart: function() {
+        return appendSegmentRequestKeyPart;
+    },
+    convertSegmentPathToStaticExportFilename: function() {
+        return convertSegmentPathToStaticExportFilename;
+    },
+    createSegmentRequestKeyPart: function() {
+        return createSegmentRequestKeyPart;
+    }
+});
+const _segment = require("../segment");
+const ROOT_SEGMENT_REQUEST_KEY = '';
+const HEAD_REQUEST_KEY = '/_head';
+function createSegmentRequestKeyPart(segment) {
+    if (typeof segment === 'string') {
+        if (segment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
+            // The Flight Router State type sometimes includes the search params in
+            // the page segment. However, the Segment Cache tracks this as a separate
+            // key. So, we strip the search params here, and then add them back when
+            // the cache entry is turned back into a FlightRouterState. This is an
+            // unfortunate consequence of the FlightRouteState being used both as a
+            // transport type and as a cache key; we'll address this once more of the
+            // Segment Cache implementation has settled.
+            // TODO: We should hoist the search params out of the FlightRouterState
+            // type entirely, This is our plan for dynamic route params, too.
+            return _segment.PAGE_SEGMENT_KEY;
+        }
+        const safeName = // TODO: FlightRouterState encodes Not Found routes as "/_not-found".
+        // But params typically don't include the leading slash. We should use
+        // a different encoding to avoid this special case.
+        segment === '/_not-found' ? '_not-found' : encodeToFilesystemAndURLSafeString(segment);
+        // Since this is not a dynamic segment, it's fully encoded. It does not
+        // need to be "hydrated" with a param value.
+        return safeName;
+    }
+    const name = segment[0];
+    const paramType = segment[2];
+    const safeName = encodeToFilesystemAndURLSafeString(name);
+    const encodedName = '$' + paramType + '$' + safeName;
+    return encodedName;
+}
+function appendSegmentRequestKeyPart(parentRequestKey, parallelRouteKey, childRequestKeyPart) {
+    // Aside from being filesystem safe, segment keys are also designed so that
+    // each segment and parallel route creates its own subdirectory. Roughly in
+    // the same shape as the source app directory. This is mostly just for easier
+    // debugging (you can open up the build folder and navigate the output); if
+    // we wanted to do we could just use a flat structure.
+    // Omit the parallel route key for children, since this is the most
+    // common case. Saves some bytes (and it's what the app directory does).
+    const slotKey = parallelRouteKey === 'children' ? childRequestKeyPart : `@${encodeToFilesystemAndURLSafeString(parallelRouteKey)}/${childRequestKeyPart}`;
+    return parentRequestKey + '/' + slotKey;
+}
+// Define a regex pattern to match the most common characters found in a route
+// param. It excludes anything that might not be cross-platform filesystem
+// compatible, like |. It does not need to be precise because the fallback is to
+// just base64url-encode the whole parameter, which is fine; we just don't do it
+// by default for compactness, and for easier debugging.
+const simpleParamValueRegex = /^[a-zA-Z0-9\-_@]+$/;
+function encodeToFilesystemAndURLSafeString(value) {
+    if (simpleParamValueRegex.test(value)) {
+        return value;
+    }
+    // If there are any unsafe characters, base64url-encode the entire value.
+    // We also add a ! prefix so it doesn't collide with the simple case.
+    const base64url = btoa(value).replace(/\+/g, '-') // Replace '+' with '-'
+    .replace(/\//g, '_') // Replace '/' with '_'
+    .replace(/=+$/, '') // Remove trailing '='
+    ;
+    return '!' + base64url;
+}
+function convertSegmentPathToStaticExportFilename(segmentPath) {
+    return `__next${segmentPath.replace(/\//g, '.')}.txt`;
+}
+
+//# sourceMappingURL=segment-value-encoding.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.js

@@ -0,0 +1,32 @@
+/**
+ * Vary Params Decoding
+ *
+ * This module is shared between server and client.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "readVaryParams", {
+    enumerable: true,
+    get: function() {
+        return readVaryParams;
+    }
+});
+function readVaryParams(thenable) {
+    // Attach a no-op listener to force Flight to synchronously resolve the
+    // thenable. When a thenable arrives from the Flight stream, it may be in an
+    // intermediate 'resolved_model' state (data received but not unwrapped).
+    // Calling .then() triggers Flight to transition it to 'fulfilled', making
+    // the value available synchronously. React uses this same optimization
+    // internally to avoid unnecessary microtasks.
+    thenable.then(noop);
+    // If the thenable is still not 'fulfilled' after calling .then(), the server
+    // failed to resolve it before the stream ended. Treat as unknown.
+    if (thenable.status !== 'fulfilled') {
+        return null;
+    }
+    return thenable.value;
+}
+const noop = ()=>{};
+
+//# sourceMappingURL=vary-params-decoding.js.map