lkd-web-kit 0.7.9 → 0.7.11

package/dist/node_modules/next/dist/shared/lib/router/utils/format-url.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const formatUrl = require('../../../../../../../_virtual/format-url.cjs');
+const _interop_require_wildcard = require('../../../../../../@swc/helpers/cjs/_interop_require_wildcard.cjs');
+const querystring = require('./querystring.cjs');
+
+var hasRequiredFormatUrl;
+
+function requireFormatUrl () {
+	if (hasRequiredFormatUrl) return formatUrl.__exports;
+	hasRequiredFormatUrl = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    formatUrl: function() {
+		        return formatUrl;
+		    },
+		    formatWithValidation: function() {
+		        return formatWithValidation;
+		    },
+		    urlObjectKeys: function() {
+		        return urlObjectKeys;
+		    }
+		});
+		const _interop_require_wildcard$1 = /*@__PURE__*/ _interop_require_wildcard.__require();
+		const _querystring = /*#__PURE__*/ _interop_require_wildcard$1._(querystring.__require());
+		const slashedProtocols = /https?|ftp|gopher|file/;
+		function formatUrl(urlObj) {
+		    let { auth, hostname } = urlObj;
+		    let protocol = urlObj.protocol || '';
+		    let pathname = urlObj.pathname || '';
+		    let hash = urlObj.hash || '';
+		    let query = urlObj.query || '';
+		    let host = false;
+		    auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ':') + '@' : '';
+		    if (urlObj.host) {
+		        host = auth + urlObj.host;
+		    } else if (hostname) {
+		        host = auth + (~hostname.indexOf(':') ? `[${hostname}]` : hostname);
+		        if (urlObj.port) {
+		            host += ':' + urlObj.port;
+		        }
+		    }
+		    if (query && typeof query === 'object') {
+		        query = String(_querystring.urlQueryToSearchParams(query));
+		    }
+		    let search = urlObj.search || query && `?${query}` || '';
+		    if (protocol && !protocol.endsWith(':')) protocol += ':';
+		    if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+		        host = '//' + (host || '');
+		        if (pathname && pathname[0] !== '/') pathname = '/' + pathname;
+		    } else if (!host) {
+		        host = '';
+		    }
+		    if (hash && hash[0] !== '#') hash = '#' + hash;
+		    if (search && search[0] !== '?') search = '?' + search;
+		    pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+		    search = search.replace('#', '%23');
+		    return `${protocol}${host}${pathname}${search}${hash}`;
+		}
+		const urlObjectKeys = [
+		    'auth',
+		    'hash',
+		    'host',
+		    'hostname',
+		    'href',
+		    'path',
+		    'pathname',
+		    'port',
+		    'protocol',
+		    'query',
+		    'search',
+		    'slashes'
+		];
+		function formatWithValidation(url) {
+		    if (process.env.NODE_ENV === 'development') {
+		        if (url !== null && typeof url === 'object') {
+		            Object.keys(url).forEach((key)=>{
+		                if (!urlObjectKeys.includes(key)) {
+		                    console.warn(`Unknown key passed via urlObject into url.format: ${key}`);
+		                }
+		            });
+		        }
+		    }
+		    return formatUrl(url);
+		}
+
+		
+	} (formatUrl.__exports));
+	return formatUrl.__exports;
+}
+
+exports.__require = requireFormatUrl;

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

@@ -0,0 +1,99 @@
+import { __exports as formatUrl } from '../../../../../../../_virtual/format-url.js';
+import { __require as require_interop_require_wildcard } from '../../../../../../@swc/helpers/cjs/_interop_require_wildcard.js';
+import { __require as requireQuerystring } from './querystring.js';
+
+var hasRequiredFormatUrl;
+
+function requireFormatUrl () {
+	if (hasRequiredFormatUrl) return formatUrl;
+	hasRequiredFormatUrl = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    formatUrl: function() {
+		        return formatUrl;
+		    },
+		    formatWithValidation: function() {
+		        return formatWithValidation;
+		    },
+		    urlObjectKeys: function() {
+		        return urlObjectKeys;
+		    }
+		});
+		const _interop_require_wildcard = /*@__PURE__*/ require_interop_require_wildcard();
+		const _querystring = /*#__PURE__*/ _interop_require_wildcard._(requireQuerystring());
+		const slashedProtocols = /https?|ftp|gopher|file/;
+		function formatUrl(urlObj) {
+		    let { auth, hostname } = urlObj;
+		    let protocol = urlObj.protocol || '';
+		    let pathname = urlObj.pathname || '';
+		    let hash = urlObj.hash || '';
+		    let query = urlObj.query || '';
+		    let host = false;
+		    auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ':') + '@' : '';
+		    if (urlObj.host) {
+		        host = auth + urlObj.host;
+		    } else if (hostname) {
+		        host = auth + (~hostname.indexOf(':') ? `[${hostname}]` : hostname);
+		        if (urlObj.port) {
+		            host += ':' + urlObj.port;
+		        }
+		    }
+		    if (query && typeof query === 'object') {
+		        query = String(_querystring.urlQueryToSearchParams(query));
+		    }
+		    let search = urlObj.search || query && `?${query}` || '';
+		    if (protocol && !protocol.endsWith(':')) protocol += ':';
+		    if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+		        host = '//' + (host || '');
+		        if (pathname && pathname[0] !== '/') pathname = '/' + pathname;
+		    } else if (!host) {
+		        host = '';
+		    }
+		    if (hash && hash[0] !== '#') hash = '#' + hash;
+		    if (search && search[0] !== '?') search = '?' + search;
+		    pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+		    search = search.replace('#', '%23');
+		    return `${protocol}${host}${pathname}${search}${hash}`;
+		}
+		const urlObjectKeys = [
+		    'auth',
+		    'hash',
+		    'host',
+		    'hostname',
+		    'href',
+		    'path',
+		    'pathname',
+		    'port',
+		    'protocol',
+		    'query',
+		    'search',
+		    'slashes'
+		];
+		function formatWithValidation(url) {
+		    if (process.env.NODE_ENV === 'development') {
+		        if (url !== null && typeof url === 'object') {
+		            Object.keys(url).forEach((key)=>{
+		                if (!urlObjectKeys.includes(key)) {
+		                    console.warn(`Unknown key passed via urlObject into url.format: ${key}`);
+		                }
+		            });
+		        }
+		    }
+		    return formatUrl(url);
+		}
+
+		
+	} (formatUrl));
+	return formatUrl;
+}
+
+export { requireFormatUrl as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/get-asset-path-from-route.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getAssetPathFromRoute = require('../../../../../../../_virtual/get-asset-path-from-route.cjs');
+
+var hasRequiredGetAssetPathFromRoute;
+
+function requireGetAssetPathFromRoute () {
+	if (hasRequiredGetAssetPathFromRoute) return getAssetPathFromRoute.__exports;
+	hasRequiredGetAssetPathFromRoute = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "default", {
+		    enumerable: true,
+		    get: function() {
+		        return getAssetPathFromRoute;
+		    }
+		});
+		function getAssetPathFromRoute(route, ext = '') {
+		    const path = route === '/' ? '/index' : /^\/index(\/|$)/.test(route) ? `/index${route}` : route;
+		    return path + ext;
+		}
+
+		
+	} (getAssetPathFromRoute.__exports));
+	return getAssetPathFromRoute.__exports;
+}
+
+exports.__require = requireGetAssetPathFromRoute;

package/dist/node_modules/next/dist/shared/lib/router/utils/get-asset-path-from-route.js

@@ -0,0 +1,28 @@
+import { __exports as getAssetPathFromRoute } from '../../../../../../../_virtual/get-asset-path-from-route.js';
+
+var hasRequiredGetAssetPathFromRoute;
+
+function requireGetAssetPathFromRoute () {
+	if (hasRequiredGetAssetPathFromRoute) return getAssetPathFromRoute;
+	hasRequiredGetAssetPathFromRoute = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "default", {
+		    enumerable: true,
+		    get: function() {
+		        return getAssetPathFromRoute;
+		    }
+		});
+		function getAssetPathFromRoute(route, ext = '') {
+		    const path = route === '/' ? '/index' : /^\/index(\/|$)/.test(route) ? `/index${route}` : route;
+		    return path + ext;
+		}
+
+		
+	} (getAssetPathFromRoute));
+	return getAssetPathFromRoute;
+}
+
+export { requireGetAssetPathFromRoute as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.cjs

@@ -0,0 +1,208 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getDynamicParam = require('../../../../../../../_virtual/get-dynamic-param.cjs');
+const invariantError = require('../../invariant-error.cjs');
+const parseLoaderTree = require('./parse-loader-tree.cjs');
+const getSegmentParam = require('./get-segment-param.cjs');
+
+var hasRequiredGetDynamicParam;
+
+function requireGetDynamicParam () {
+	if (hasRequiredGetDynamicParam) return getDynamicParam.__exports;
+	hasRequiredGetDynamicParam = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    PARAMETER_PATTERN: function() {
+		        return PARAMETER_PATTERN;
+		    },
+		    getDynamicParam: function() {
+		        return getDynamicParam;
+		    },
+		    interpolateParallelRouteParams: function() {
+		        return interpolateParallelRouteParams;
+		    },
+		    parseMatchedParameter: function() {
+		        return parseMatchedParameter;
+		    },
+		    parseParameter: function() {
+		        return parseParameter;
+		    }
+		});
+		const _invarianterror = invariantError.__require();
+		const _parseloadertree = parseLoaderTree.__require();
+		const _getsegmentparam = getSegmentParam.__require();
+		/**
+		 * Gets the value of a param from the params object. This correctly handles the
+		 * case where the param is a fallback route param and encodes the resulting
+		 * value.
+		 *
+		 * @param interpolatedParams - The params object.
+		 * @param segmentKey - The key of the segment.
+		 * @param fallbackRouteParams - The fallback route params.
+		 * @returns The value of the param.
+		 */ function getParamValue(interpolatedParams, segmentKey, fallbackRouteParams) {
+		    let value = interpolatedParams[segmentKey];
+		    if (fallbackRouteParams?.has(segmentKey)) {
+		        // We know that the fallback route params has the segment key because we
+		        // checked that above.
+		        const [searchValue] = fallbackRouteParams.get(segmentKey);
+		        value = searchValue;
+		    } else if (Array.isArray(value)) {
+		        value = value.map((i)=>encodeURIComponent(i));
+		    } else if (typeof value === 'string') {
+		        value = encodeURIComponent(value);
+		    }
+		    return value;
+		}
+		function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRouteParams) {
+		    const interpolated = structuredClone(params);
+		    // Stack-based traversal with depth tracking
+		    const stack = [
+		        {
+		            tree: loaderTree,
+		            depth: 0
+		        }
+		    ];
+		    // Derive value from pagePath based on depth and parameter type
+		    const pathSegments = pagePath.split('/').slice(1) // Remove first empty string
+		    ;
+		    while(stack.length > 0){
+		        const { tree, depth } = stack.pop();
+		        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+		        // Check if current segment contains a parameter
+		        const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+		        if (segmentParam && !interpolated.hasOwnProperty(segmentParam.param) && // If the param is in the fallback route params, we don't need to
+		        // interpolate it because it's already marked as being unknown.
+		        !fallbackRouteParams?.has(segmentParam.param)) {
+		            switch(segmentParam.type){
+		                case 'catchall':
+		                case 'optional-catchall':
+		                case 'catchall-intercepted-(..)(..)':
+		                case 'catchall-intercepted-(.)':
+		                case 'catchall-intercepted-(..)':
+		                case 'catchall-intercepted-(...)':
+		                    // For catchall parameters, take all remaining segments from this depth
+		                    const remainingSegments = pathSegments.slice(depth);
+		                    // Process each segment to handle any dynamic params
+		                    const processedSegments = remainingSegments.flatMap((pathSegment)=>{
+		                        const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+		                        // If the segment matches a param, return the param value otherwise,
+		                        // it's a static segment, so just return that. We don't use the
+		                        // `getParamValue` function here because we don't want the values to
+		                        // be encoded, that's handled on get by the `getDynamicParam`
+		                        // function.
+		                        return param ? interpolated[param.param] : pathSegment;
+		                    }).filter((s)=>s !== undefined);
+		                    if (processedSegments.length > 0) {
+		                        interpolated[segmentParam.param] = processedSegments;
+		                    }
+		                    break;
+		                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 < pathSegments.length) {
+		                        const pathSegment = pathSegments[depth];
+		                        const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+		                        interpolated[segmentParam.param] = param ? interpolated[param.param] : pathSegment;
+		                    }
+		                    break;
+		                default:
+		                    segmentParam.type;
+		            }
+		        }
+		        // Calculate next depth - increment if this is not a route group and not empty
+		        let nextDepth = depth;
+		        const isRouteGroup = segment.startsWith('(') && segment.endsWith(')');
+		        if (!isRouteGroup && segment !== '') {
+		            nextDepth++;
+		        }
+		        // Add all parallel routes to the stack for processing
+		        for (const route of Object.values(parallelRoutes)){
+		            stack.push({
+		                tree: route,
+		                depth: nextDepth
+		            });
+		        }
+		    }
+		    return interpolated;
+		}
+		function getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams) {
+		    let value = getParamValue(interpolatedParams, segmentKey, fallbackRouteParams);
+		    // handle the case where an optional catchall does not have a value,
+		    // e.g. `/dashboard/[[...slug]]` when requesting `/dashboard`
+		    if (!value || value.length === 0) {
+		        if (dynamicParamType === 'oc') {
+		            return {
+		                param: segmentKey,
+		                value: null,
+		                type: dynamicParamType,
+		                treeSegment: [
+		                    segmentKey,
+		                    '',
+		                    dynamicParamType
+		                ]
+		            };
+		        }
+		        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`), "__NEXT_ERROR_CODE", {
+		            value: "E864",
+		            enumerable: false,
+		            configurable: true
+		        });
+		    }
+		    return {
+		        param: segmentKey,
+		        // The value that is passed to user code.
+		        value,
+		        // The value that is rendered in the router tree.
+		        treeSegment: [
+		            segmentKey,
+		            Array.isArray(value) ? value.join('/') : value,
+		            dynamicParamType
+		        ],
+		        type: dynamicParamType
+		    };
+		}
+		const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+		function parseParameter(param) {
+		    const match = param.match(PARAMETER_PATTERN);
+		    if (!match) {
+		        return parseMatchedParameter(param);
+		    }
+		    return parseMatchedParameter(match[2]);
+		}
+		function parseMatchedParameter(param) {
+		    const optional = param.startsWith('[') && param.endsWith(']');
+		    if (optional) {
+		        param = param.slice(1, -1);
+		    }
+		    const repeat = param.startsWith('...');
+		    if (repeat) {
+		        param = param.slice(3);
+		    }
+		    return {
+		        key: param,
+		        repeat,
+		        optional
+		    };
+		}
+
+		
+	} (getDynamicParam.__exports));
+	return getDynamicParam.__exports;
+}
+
+exports.__require = requireGetDynamicParam;

package/dist/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js

@@ -0,0 +1,204 @@
+import { __exports as getDynamicParam } from '../../../../../../../_virtual/get-dynamic-param.js';
+import { __require as requireInvariantError } from '../../invariant-error.js';
+import { __require as requireParseLoaderTree } from './parse-loader-tree.js';
+import { __require as requireGetSegmentParam } from './get-segment-param.js';
+
+var hasRequiredGetDynamicParam;
+
+function requireGetDynamicParam () {
+	if (hasRequiredGetDynamicParam) return getDynamicParam;
+	hasRequiredGetDynamicParam = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    PARAMETER_PATTERN: function() {
+		        return PARAMETER_PATTERN;
+		    },
+		    getDynamicParam: function() {
+		        return getDynamicParam;
+		    },
+		    interpolateParallelRouteParams: function() {
+		        return interpolateParallelRouteParams;
+		    },
+		    parseMatchedParameter: function() {
+		        return parseMatchedParameter;
+		    },
+		    parseParameter: function() {
+		        return parseParameter;
+		    }
+		});
+		const _invarianterror = requireInvariantError();
+		const _parseloadertree = requireParseLoaderTree();
+		const _getsegmentparam = requireGetSegmentParam();
+		/**
+		 * Gets the value of a param from the params object. This correctly handles the
+		 * case where the param is a fallback route param and encodes the resulting
+		 * value.
+		 *
+		 * @param interpolatedParams - The params object.
+		 * @param segmentKey - The key of the segment.
+		 * @param fallbackRouteParams - The fallback route params.
+		 * @returns The value of the param.
+		 */ function getParamValue(interpolatedParams, segmentKey, fallbackRouteParams) {
+		    let value = interpolatedParams[segmentKey];
+		    if (fallbackRouteParams?.has(segmentKey)) {
+		        // We know that the fallback route params has the segment key because we
+		        // checked that above.
+		        const [searchValue] = fallbackRouteParams.get(segmentKey);
+		        value = searchValue;
+		    } else if (Array.isArray(value)) {
+		        value = value.map((i)=>encodeURIComponent(i));
+		    } else if (typeof value === 'string') {
+		        value = encodeURIComponent(value);
+		    }
+		    return value;
+		}
+		function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRouteParams) {
+		    const interpolated = structuredClone(params);
+		    // Stack-based traversal with depth tracking
+		    const stack = [
+		        {
+		            tree: loaderTree,
+		            depth: 0
+		        }
+		    ];
+		    // Derive value from pagePath based on depth and parameter type
+		    const pathSegments = pagePath.split('/').slice(1) // Remove first empty string
+		    ;
+		    while(stack.length > 0){
+		        const { tree, depth } = stack.pop();
+		        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+		        // Check if current segment contains a parameter
+		        const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+		        if (segmentParam && !interpolated.hasOwnProperty(segmentParam.param) && // If the param is in the fallback route params, we don't need to
+		        // interpolate it because it's already marked as being unknown.
+		        !fallbackRouteParams?.has(segmentParam.param)) {
+		            switch(segmentParam.type){
+		                case 'catchall':
+		                case 'optional-catchall':
+		                case 'catchall-intercepted-(..)(..)':
+		                case 'catchall-intercepted-(.)':
+		                case 'catchall-intercepted-(..)':
+		                case 'catchall-intercepted-(...)':
+		                    // For catchall parameters, take all remaining segments from this depth
+		                    const remainingSegments = pathSegments.slice(depth);
+		                    // Process each segment to handle any dynamic params
+		                    const processedSegments = remainingSegments.flatMap((pathSegment)=>{
+		                        const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+		                        // If the segment matches a param, return the param value otherwise,
+		                        // it's a static segment, so just return that. We don't use the
+		                        // `getParamValue` function here because we don't want the values to
+		                        // be encoded, that's handled on get by the `getDynamicParam`
+		                        // function.
+		                        return param ? interpolated[param.param] : pathSegment;
+		                    }).filter((s)=>s !== undefined);
+		                    if (processedSegments.length > 0) {
+		                        interpolated[segmentParam.param] = processedSegments;
+		                    }
+		                    break;
+		                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 < pathSegments.length) {
+		                        const pathSegment = pathSegments[depth];
+		                        const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+		                        interpolated[segmentParam.param] = param ? interpolated[param.param] : pathSegment;
+		                    }
+		                    break;
+		                default:
+		                    segmentParam.type;
+		            }
+		        }
+		        // Calculate next depth - increment if this is not a route group and not empty
+		        let nextDepth = depth;
+		        const isRouteGroup = segment.startsWith('(') && segment.endsWith(')');
+		        if (!isRouteGroup && segment !== '') {
+		            nextDepth++;
+		        }
+		        // Add all parallel routes to the stack for processing
+		        for (const route of Object.values(parallelRoutes)){
+		            stack.push({
+		                tree: route,
+		                depth: nextDepth
+		            });
+		        }
+		    }
+		    return interpolated;
+		}
+		function getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams) {
+		    let value = getParamValue(interpolatedParams, segmentKey, fallbackRouteParams);
+		    // handle the case where an optional catchall does not have a value,
+		    // e.g. `/dashboard/[[...slug]]` when requesting `/dashboard`
+		    if (!value || value.length === 0) {
+		        if (dynamicParamType === 'oc') {
+		            return {
+		                param: segmentKey,
+		                value: null,
+		                type: dynamicParamType,
+		                treeSegment: [
+		                    segmentKey,
+		                    '',
+		                    dynamicParamType
+		                ]
+		            };
+		        }
+		        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`), "__NEXT_ERROR_CODE", {
+		            value: "E864",
+		            enumerable: false,
+		            configurable: true
+		        });
+		    }
+		    return {
+		        param: segmentKey,
+		        // The value that is passed to user code.
+		        value,
+		        // The value that is rendered in the router tree.
+		        treeSegment: [
+		            segmentKey,
+		            Array.isArray(value) ? value.join('/') : value,
+		            dynamicParamType
+		        ],
+		        type: dynamicParamType
+		    };
+		}
+		const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+		function parseParameter(param) {
+		    const match = param.match(PARAMETER_PATTERN);
+		    if (!match) {
+		        return parseMatchedParameter(param);
+		    }
+		    return parseMatchedParameter(match[2]);
+		}
+		function parseMatchedParameter(param) {
+		    const optional = param.startsWith('[') && param.endsWith(']');
+		    if (optional) {
+		        param = param.slice(1, -1);
+		    }
+		    const repeat = param.startsWith('...');
+		    if (repeat) {
+		        param = param.slice(3);
+		    }
+		    return {
+		        key: param,
+		        repeat,
+		        optional
+		    };
+		}
+
+		
+	} (getDynamicParam));
+	return getDynamicParam;
+}
+
+export { requireGetDynamicParam as __require };