putmein-test 1.0.0

package/dist/ray/node_modules/next/dist/shared/lib/router/utils/prepare-destination.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    compileNonPath: null,
+    matchHas: null,
+    parseDestination: null,
+    prepareDestination: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    compileNonPath: function() {
+        return compileNonPath;
+    },
+    matchHas: function() {
+        return matchHas;
+    },
+    parseDestination: function() {
+        return parseDestination;
+    },
+    prepareDestination: function() {
+        return prepareDestination;
+    }
+});
+const _escaperegexp = require("../../escape-regexp");
+const _parseurl = require("./parse-url");
+const _interceptionroutes = require("./interception-routes");
+const _getcookieparser = require("../../../../server/api-utils/get-cookie-parser");
+const _routematchutils = require("./route-match-utils");
+/**
+ * Ensure only a-zA-Z are used for param names for proper interpolating
+ * with path-to-regexp
+ */ function getSafeParamName(paramName) {
+    let newParamName = '';
+    for(let i = 0; i < paramName.length; i++){
+        const charCode = paramName.charCodeAt(i);
+        if (charCode > 64 && charCode < 91 || // A-Z
+        charCode > 96 && charCode < 123 // a-z
+        ) {
+            newParamName += paramName[i];
+        }
+    }
+    return newParamName;
+}
+function escapeSegment(str, segmentName) {
+    return str.replace(new RegExp(`:${(0, _escaperegexp.escapeStringRegexp)(segmentName)}`, 'g'), `__ESC_COLON_${segmentName}`);
+}
+function unescapeSegments(str) {
+    return str.replace(/__ESC_COLON_/gi, ':');
+}
+function matchHas(req, query, has = [], missing = []) {
+    const params = {};
+    const hasMatch = (hasItem)=>{
+        let value;
+        let key = hasItem.key;
+        switch(hasItem.type){
+            case 'header':
+                {
+                    key = key.toLowerCase();
+                    value = req.headers[key];
+                    break;
+                }
+            case 'cookie':
+                {
+                    if ('cookies' in req) {
+                        value = req.cookies[hasItem.key];
+                    } else {
+                        const cookies = (0, _getcookieparser.getCookieParser)(req.headers)();
+                        value = cookies[hasItem.key];
+                    }
+                    break;
+                }
+            case 'query':
+                {
+                    value = query[key];
+                    break;
+                }
+            case 'host':
+                {
+                    const { host } = req?.headers || {};
+                    // remove port from host if present
+                    const hostname = host?.split(':', 1)[0].toLowerCase();
+                    value = hostname;
+                    break;
+                }
+            default:
+                {
+                    break;
+                }
+        }
+        if (!hasItem.value && value) {
+            params[getSafeParamName(key)] = value;
+            return true;
+        } else if (value) {
+            const matcher = new RegExp(`^${hasItem.value}$`);
+            const matches = Array.isArray(value) ? value.slice(-1)[0].match(matcher) : value.match(matcher);
+            if (matches) {
+                if (Array.isArray(matches)) {
+                    if (matches.groups) {
+                        Object.keys(matches.groups).forEach((groupKey)=>{
+                            params[groupKey] = matches.groups[groupKey];
+                        });
+                    } else if (hasItem.type === 'host' && matches[0]) {
+                        params.host = matches[0];
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    };
+    const allMatch = has.every((item)=>hasMatch(item)) && !missing.some((item)=>hasMatch(item));
+    if (allMatch) {
+        return params;
+    }
+    return false;
+}
+function compileNonPath(value, params) {
+    if (!value.includes(':')) {
+        return value;
+    }
+    for (const key of Object.keys(params)){
+        if (value.includes(`:${key}`)) {
+            value = value.replace(new RegExp(`:${key}\\*`, 'g'), `:${key}--ESCAPED_PARAM_ASTERISKS`).replace(new RegExp(`:${key}\\?`, 'g'), `:${key}--ESCAPED_PARAM_QUESTION`).replace(new RegExp(`:${key}\\+`, 'g'), `:${key}--ESCAPED_PARAM_PLUS`).replace(new RegExp(`:${key}(?!\\w)`, 'g'), `--ESCAPED_PARAM_COLON${key}`);
+        }
+    }
+    value = value.replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, '\\$1').replace(/--ESCAPED_PARAM_PLUS/g, '+').replace(/--ESCAPED_PARAM_COLON/g, ':').replace(/--ESCAPED_PARAM_QUESTION/g, '?').replace(/--ESCAPED_PARAM_ASTERISKS/g, '*');
+    // the value needs to start with a forward-slash to be compiled
+    // correctly
+    return (0, _routematchutils.safeCompile)(`/${value}`, {
+        validate: false
+    })(params).slice(1);
+}
+function parseDestination(args) {
+    let escaped = args.destination;
+    for (const param of Object.keys({
+        ...args.params,
+        ...args.query
+    })){
+        if (!param) continue;
+        escaped = escapeSegment(escaped, param);
+    }
+    const parsed = (0, _parseurl.parseUrl)(escaped);
+    let pathname = parsed.pathname;
+    if (pathname) {
+        pathname = unescapeSegments(pathname);
+    }
+    let href = parsed.href;
+    if (href) {
+        href = unescapeSegments(href);
+    }
+    let hostname = parsed.hostname;
+    if (hostname) {
+        hostname = unescapeSegments(hostname);
+    }
+    let hash = parsed.hash;
+    if (hash) {
+        hash = unescapeSegments(hash);
+    }
+    let search = parsed.search;
+    if (search) {
+        search = unescapeSegments(search);
+    }
+    let origin = parsed.origin;
+    if (origin) {
+        origin = unescapeSegments(origin);
+    }
+    return {
+        ...parsed,
+        pathname,
+        hostname,
+        href,
+        hash,
+        search,
+        origin
+    };
+}
+function prepareDestination(args) {
+    const parsedDestination = parseDestination(args);
+    const { hostname: destHostname, query: destQuery, search: destSearch } = parsedDestination;
+    // The following code assumes that the pathname here includes the hash if it's
+    // present.
+    let destPath = parsedDestination.pathname;
+    if (parsedDestination.hash) {
+        destPath = `${destPath}${parsedDestination.hash}`;
+    }
+    const destParams = [];
+    const destPathParamKeys = [];
+    (0, _routematchutils.safePathToRegexp)(destPath, destPathParamKeys);
+    for (const key of destPathParamKeys){
+        destParams.push(key.name);
+    }
+    if (destHostname) {
+        const destHostnameParamKeys = [];
+        (0, _routematchutils.safePathToRegexp)(destHostname, destHostnameParamKeys);
+        for (const key of destHostnameParamKeys){
+            destParams.push(key.name);
+        }
+    }
+    const destPathCompiler = (0, _routematchutils.safeCompile)(destPath, // we don't validate while compiling the destination since we should
+    // have already validated before we got to this point and validating
+    // breaks compiling destinations with named pattern params from the source
+    // e.g. /something:hello(.*) -> /another/:hello is broken with validation
+    // since compile validation is meant for reversing and not for inserting
+    // params from a separate path-regex into another
+    {
+        validate: false
+    });
+    let destHostnameCompiler;
+    if (destHostname) {
+        destHostnameCompiler = (0, _routematchutils.safeCompile)(destHostname, {
+            validate: false,
+            encode: encodeURIComponent
+        });
+    }
+    // update any params in query values
+    for (const [key, strOrArray] of Object.entries(destQuery)){
+        // the value needs to start with a forward-slash to be compiled
+        // correctly
+        if (Array.isArray(strOrArray)) {
+            destQuery[key] = strOrArray.map((value)=>compileNonPath(unescapeSegments(value), args.params));
+        } else if (typeof strOrArray === 'string') {
+            destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params);
+        }
+    }
+    // add path params to query if it's not a redirect and not
+    // already defined in destination query or path
+    let paramKeys = Object.keys(args.params).filter((name)=>name !== 'nextInternalLocale');
+    if (args.appendParamsToQuery && !paramKeys.some((key)=>destParams.includes(key))) {
+        for (const key of paramKeys){
+            if (!(key in destQuery)) {
+                destQuery[key] = args.params[key];
+            }
+        }
+    }
+    let newUrl;
+    // The compiler also that the interception route marker is an unnamed param, hence '0',
+    // so we need to add it to the params object.
+    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(destPath)) {
+        for (const segment of destPath.split('/')){
+            const marker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+            if (marker) {
+                if (marker === '(..)(..)') {
+                    args.params['0'] = '(..)';
+                    args.params['1'] = '(..)';
+                } else {
+                    args.params['0'] = marker;
+                }
+                break;
+            }
+        }
+    }
+    try {
+        newUrl = destPathCompiler(args.params);
+        const [pathname, hash] = newUrl.split('#', 2);
+        if (destHostnameCompiler) {
+            parsedDestination.hostname = destHostnameCompiler(args.params);
+        }
+        parsedDestination.pathname = pathname;
+        parsedDestination.hash = `${hash ? '#' : ''}${hash || ''}`;
+        parsedDestination.search = destSearch ? compileNonPath(destSearch, args.params) : '';
+    } catch (err) {
+        if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
+            throw Object.defineProperty(new Error(`To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`), "__NEXT_ERROR_CODE", {
+                value: "E329",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        throw err;
+    }
+    // Query merge order lowest priority to highest
+    // 1. initial URL query values
+    // 2. path segment values
+    // 3. destination specified query values
+    parsedDestination.query = {
+        ...args.query,
+        ...parsedDestination.query
+    };
+    return {
+        newUrl,
+        destQuery,
+        parsedDestination
+    };
+}
+
+//# sourceMappingURL=prepare-destination.js.map

package/dist/ray/node_modules/next/dist/shared/lib/router/utils/querystring.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    assign: null,
+    searchParamsToUrlQuery: null,
+    urlQueryToSearchParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    assign: function() {
+        return assign;
+    },
+    searchParamsToUrlQuery: function() {
+        return searchParamsToUrlQuery;
+    },
+    urlQueryToSearchParams: function() {
+        return urlQueryToSearchParams;
+    }
+});
+function searchParamsToUrlQuery(searchParams) {
+    const query = {};
+    for (const [key, value] of searchParams.entries()){
+        const existing = query[key];
+        if (typeof existing === 'undefined') {
+            query[key] = value;
+        } else if (Array.isArray(existing)) {
+            existing.push(value);
+        } else {
+            query[key] = [
+                existing,
+                value
+            ];
+        }
+    }
+    return query;
+}
+function stringifyUrlQueryParam(param) {
+    if (typeof param === 'string') {
+        return param;
+    }
+    if (typeof param === 'number' && !isNaN(param) || typeof param === 'boolean') {
+        return String(param);
+    } else {
+        return '';
+    }
+}
+function urlQueryToSearchParams(query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)){
+        if (Array.isArray(value)) {
+            for (const item of value){
+                searchParams.append(key, stringifyUrlQueryParam(item));
+            }
+        } else {
+            searchParams.set(key, stringifyUrlQueryParam(value));
+        }
+    }
+    return searchParams;
+}
+function assign(target, ...searchParamsList) {
+    for (const searchParams of searchParamsList){
+        for (const key of searchParams.keys()){
+            target.delete(key);
+        }
+        for (const [key, value] of searchParams.entries()){
+            target.append(key, value);
+        }
+    }
+    return target;
+}
+
+//# sourceMappingURL=querystring.js.map

package/dist/ray/node_modules/next/dist/shared/lib/router/utils/relativize-url.js

@@ -0,0 +1,40 @@
+/**
+ * The result of parsing a URL relative to a base URL.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getRelativeURL: null,
+    parseRelativeURL: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getRelativeURL: function() {
+        return getRelativeURL;
+    },
+    parseRelativeURL: function() {
+        return parseRelativeURL;
+    }
+});
+function parseRelativeURL(url, base) {
+    const baseURL = typeof base === 'string' ? new URL(base) : base;
+    const relative = new URL(url, base);
+    // The URL is relative if the origin is the same as the base URL.
+    const isRelative = relative.origin === baseURL.origin;
+    return {
+        url: isRelative ? relative.toString().slice(baseURL.origin.length) : relative.toString(),
+        isRelative
+    };
+}
+function getRelativeURL(url, base) {
+    const relative = parseRelativeURL(url, base);
+    return relative.url;
+}
+
+//# sourceMappingURL=relativize-url.js.map

package/dist/ray/node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removePathPrefix", {
+    enumerable: true,
+    get: function() {
+        return removePathPrefix;
+    }
+});
+const _pathhasprefix = require("./path-has-prefix");
+function removePathPrefix(path, prefix) {
+    // If the path doesn't start with the prefix we can return it as is. This
+    // protects us from situations where the prefix is a substring of the path
+    // prefix such as:
+    //
+    // For prefix: /blog
+    //
+    //   /blog -> true
+    //   /blog/ -> true
+    //   /blog/1 -> true
+    //   /blogging -> false
+    //   /blogging/ -> false
+    //   /blogging/1 -> false
+    if (!(0, _pathhasprefix.pathHasPrefix)(path, prefix)) {
+        return path;
+    }
+    // Remove the prefix from the path via slicing.
+    const withoutPrefix = path.slice(prefix.length);
+    // If the path without the prefix starts with a `/` we can return it as is.
+    if (withoutPrefix.startsWith('/')) {
+        return withoutPrefix;
+    }
+    // If the path without the prefix doesn't start with a `/` we need to add it
+    // back to the path to make sure it's a valid path.
+    return `/${withoutPrefix}`;
+}
+
+//# sourceMappingURL=remove-path-prefix.js.map

package/dist/ray/node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -0,0 +1,22 @@
+/**
+ * Removes the trailing slash for a given route or page path. Examples:
+ *   - `/foo/bar/` -> `/foo/bar`
+ *   - `/foo/bar` -> `/foo/bar`
+ *
+ * Uses charCodeAt (47 === '/') instead of regex to avoid the overhead of
+ * compiling and executing a RegExp on every call (~3-5x faster).
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeTrailingSlash", {
+    enumerable: true,
+    get: function() {
+        return removeTrailingSlash;
+    }
+});
+function removeTrailingSlash(route) {
+    return route.charCodeAt(route.length - 1) === 47 && route.length > 1 ? route.slice(0, -1) : route;
+}
+
+//# sourceMappingURL=remove-trailing-slash.js.map

package/dist/ray/node_modules/next/dist/shared/lib/router/utils/resolve-param-value.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveParamValue", {
+    enumerable: true,
+    get: function() {
+        return resolveParamValue;
+    }
+});
+const _invarianterror = require("../../invariant-error");
+const _interceptionprefixfromparamtype = require("./interception-prefix-from-param-type");
+/**
+ * Extracts the param value from a path segment, handling interception markers
+ * based on the expected param type.
+ *
+ * @param pathSegment - The path segment to extract the value from
+ * @param params - The current params object for resolving dynamic param references
+ * @param paramType - The expected param type which may include interception marker info
+ * @returns The extracted param value
+ */ function getParamValueFromSegment(pathSegment, params, paramType) {
+    // If the segment is dynamic, resolve it from the params object
+    if (pathSegment.type === 'dynamic') {
+        return params[pathSegment.param.paramName];
+    }
+    // If the paramType indicates this is an intercepted param, strip the marker
+    // that matches the interception marker in the param type
+    const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
+    if (interceptionPrefix === pathSegment.interceptionMarker) {
+        return pathSegment.name.replace(pathSegment.interceptionMarker, '');
+    }
+    // For static segments, use the name
+    return pathSegment.name;
+}
+function resolveParamValue(paramName, paramType, depth, route, params) {
+    switch(paramType){
+        case 'catchall':
+        case 'optional-catchall':
+        case 'catchall-intercepted-(..)(..)':
+        case 'catchall-intercepted-(.)':
+        case 'catchall-intercepted-(..)':
+        case 'catchall-intercepted-(...)':
+            // For catchall routes, derive from pathname using depth to determine
+            // which segments to use
+            const processedSegments = [];
+            // Process segments to handle any embedded dynamic params
+            for(let index = depth; index < route.segments.length; index++){
+                const pathSegment = route.segments[index];
+                if (pathSegment.type === 'static') {
+                    let value = pathSegment.name;
+                    // For intercepted catch-all params, strip the marker from the first segment
+                    const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
+                    if (interceptionPrefix && index === depth && interceptionPrefix === pathSegment.interceptionMarker) {
+                        // Strip the interception marker from the value
+                        value = value.replace(pathSegment.interceptionMarker, '');
+                    }
+                    processedSegments.push(value);
+                } else {
+                    // If the segment is a param placeholder, check if we have its value
+                    if (!params.hasOwnProperty(pathSegment.param.paramName)) {
+                        // If the segment is an optional catchall, we can break out of the
+                        // loop because it's optional!
+                        if (pathSegment.param.paramType === 'optional-catchall') {
+                            break;
+                        }
+                        // Unknown param placeholder in pathname - can't derive full value
+                        return undefined;
+                    }
+                    // If the segment matches a param, use the param value
+                    // We don't encode values here as that's handled during retrieval.
+                    const paramValue = params[pathSegment.param.paramName];
+                    if (Array.isArray(paramValue)) {
+                        processedSegments.push(...paramValue);
+                    } else {
+                        processedSegments.push(paramValue);
+                    }
+                }
+            }
+            if (processedSegments.length > 0) {
+                return processedSegments;
+            } else if (paramType === 'optional-catchall') {
+                return undefined;
+            } else {
+                // We shouldn't be able to match a catchall segment without any path
+                // segments if it's not an optional catchall
+                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
+                    value: "E931",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        case 'dynamic':
+        case 'dynamic-intercepted-(..)(..)':
+        case 'dynamic-intercepted-(.)':
+        case 'dynamic-intercepted-(..)':
+        case 'dynamic-intercepted-(...)':
+            // For regular dynamic parameters, take the segment at this depth
+            if (depth < route.segments.length) {
+                const pathSegment = route.segments[depth];
+                // Check if the segment at this depth is a placeholder for an unknown param
+                if (pathSegment.type === 'dynamic' && !params.hasOwnProperty(pathSegment.param.paramName)) {
+                    // The segment is a placeholder like [category] and we don't have the value
+                    return undefined;
+                }
+                // If the segment matches a param, use the param value from params object
+                // Otherwise it's a static segment, just use it directly
+                // We don't encode values here as that's handled during retrieval
+                return getParamValueFromSegment(pathSegment, params, paramType);
+            }
+            return undefined;
+        default:
+            paramType;
+    }
+}
+
+//# sourceMappingURL=resolve-param-value.js.map