lkd-web-kit 0.7.14 → 0.7.16

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

@@ -1,123 +0,0 @@
-import { __exports as routeMatchUtils } from '../../../../../../../_virtual/route-match-utils.js';
-import { __require as requirePathToRegexp } from '../../../../compiled/path-to-regexp/index.js';
-import { __require as requireRoutePatternNormalizer } from '../../../../lib/route-pattern-normalizer.js';
-
-/**
- * Client-safe utilities for route matching that don't import server-side
- * utilities to avoid bundling issues with Turbopack
- */
-
-var hasRequiredRouteMatchUtils;
-
-function requireRouteMatchUtils () {
-	if (hasRequiredRouteMatchUtils) return routeMatchUtils;
-	hasRequiredRouteMatchUtils = 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, {
-		    safeCompile: function() {
-		        return safeCompile;
-		    },
-		    safePathToRegexp: function() {
-		        return safePathToRegexp;
-		    },
-		    safeRegexpToFunction: function() {
-		        return safeRegexpToFunction;
-		    },
-		    safeRouteMatcher: function() {
-		        return safeRouteMatcher;
-		    }
-		});
-		const _pathtoregexp = requirePathToRegexp();
-		const _routepatternnormalizer = requireRoutePatternNormalizer();
-		function safePathToRegexp(route, keys, options) {
-		    if (typeof route !== 'string') {
-		        return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
-		    }
-		    // Check if normalization is needed and cache the result
-		    const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
-		    const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
-		    try {
-		        return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
-		    } catch (error) {
-		        // Only try normalization if we haven't already normalized
-		        if (!needsNormalization) {
-		            try {
-		                const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
-		                return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
-		            } catch (retryError) {
-		                // If that doesn't work, fall back to original error
-		                throw error;
-		            }
-		        }
-		        throw error;
-		    }
-		}
-		function safeCompile(route, options) {
-		    // Check if normalization is needed and cache the result
-		    const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
-		    const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
-		    try {
-		        const compiler = (0, _pathtoregexp.compile)(routeToUse, options);
-		        // If we normalized the route, wrap the compiler to strip separators from output
-		        // The normalization inserts _NEXTSEP_ as a literal string in the pattern to satisfy
-		        // path-to-regexp validation, but we don't want it in the final compiled URL
-		        if (needsNormalization) {
-		            return (params)=>{
-		                return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
-		            };
-		        }
-		        return compiler;
-		    } catch (error) {
-		        // Only try normalization if we haven't already normalized
-		        if (!needsNormalization) {
-		            try {
-		                const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
-		                const compiler = (0, _pathtoregexp.compile)(normalizedRoute, options);
-		                // Wrap the compiler to strip separators from output
-		                return (params)=>{
-		                    return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
-		                };
-		            } catch (retryError) {
-		                // If that doesn't work, fall back to original error
-		                throw error;
-		            }
-		        }
-		        throw error;
-		    }
-		}
-		function safeRegexpToFunction(regexp, keys) {
-		    const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
-		    return (pathname)=>{
-		        const result = originalMatcher(pathname);
-		        if (!result) return false;
-		        // Clean parameters before returning
-		        return {
-		            ...result,
-		            params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
-		        };
-		    };
-		}
-		function safeRouteMatcher(matcherFn) {
-		    return (pathname)=>{
-		        const result = matcherFn(pathname);
-		        if (!result) return false;
-		        // Clean parameters before returning
-		        return (0, _routepatternnormalizer.stripParameterSeparators)(result);
-		    };
-		}
-
-		
-	} (routeMatchUtils));
-	return routeMatchUtils;
-}
-
-export { requireRouteMatchUtils as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/route-matcher.cjs

@@ -1,63 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const routeMatcher = require('../../../../../../../_virtual/route-matcher.cjs');
-const utils = require('../../utils.cjs');
-const routeMatchUtils = require('./route-match-utils.cjs');
-
-var hasRequiredRouteMatcher;
-
-function requireRouteMatcher () {
-	if (hasRequiredRouteMatcher) return routeMatcher.__exports;
-	hasRequiredRouteMatcher = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", {
-		    value: true
-		});
-		Object.defineProperty(exports, "getRouteMatcher", {
-		    enumerable: true,
-		    get: function() {
-		        return getRouteMatcher;
-		    }
-		});
-		const _utils = utils.__require();
-		const _routematchutils = routeMatchUtils.__require();
-		function getRouteMatcher({ re, groups }) {
-		    const rawMatcher = (pathname)=>{
-		        const routeMatch = re.exec(pathname);
-		        if (!routeMatch) return false;
-		        const decode = (param)=>{
-		            try {
-		                return decodeURIComponent(param);
-		            } catch  {
-		                throw Object.defineProperty(new _utils.DecodeError('failed to decode param'), "__NEXT_ERROR_CODE", {
-		                    value: "E528",
-		                    enumerable: false,
-		                    configurable: true
-		                });
-		            }
-		        };
-		        const params = {};
-		        for (const [key, group] of Object.entries(groups)){
-		            const match = routeMatch[group.pos];
-		            if (match !== undefined) {
-		                if (group.repeat) {
-		                    params[key] = match.split('/').map((entry)=>decode(entry));
-		                } else {
-		                    params[key] = decode(match);
-		                }
-		            }
-		        }
-		        return params;
-		    };
-		    // Wrap with safe matcher to handle parameter cleaning
-		    return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
-		}
-
-		
-	} (routeMatcher.__exports));
-	return routeMatcher.__exports;
-}
-
-exports.__require = requireRouteMatcher;

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

@@ -1,59 +0,0 @@
-import { __exports as routeMatcher } from '../../../../../../../_virtual/route-matcher.js';
-import { __require as requireUtils } from '../../utils.js';
-import { __require as requireRouteMatchUtils } from './route-match-utils.js';
-
-var hasRequiredRouteMatcher;
-
-function requireRouteMatcher () {
-	if (hasRequiredRouteMatcher) return routeMatcher;
-	hasRequiredRouteMatcher = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", {
-		    value: true
-		});
-		Object.defineProperty(exports, "getRouteMatcher", {
-		    enumerable: true,
-		    get: function() {
-		        return getRouteMatcher;
-		    }
-		});
-		const _utils = requireUtils();
-		const _routematchutils = requireRouteMatchUtils();
-		function getRouteMatcher({ re, groups }) {
-		    const rawMatcher = (pathname)=>{
-		        const routeMatch = re.exec(pathname);
-		        if (!routeMatch) return false;
-		        const decode = (param)=>{
-		            try {
-		                return decodeURIComponent(param);
-		            } catch  {
-		                throw Object.defineProperty(new _utils.DecodeError('failed to decode param'), "__NEXT_ERROR_CODE", {
-		                    value: "E528",
-		                    enumerable: false,
-		                    configurable: true
-		                });
-		            }
-		        };
-		        const params = {};
-		        for (const [key, group] of Object.entries(groups)){
-		            const match = routeMatch[group.pos];
-		            if (match !== undefined) {
-		                if (group.repeat) {
-		                    params[key] = match.split('/').map((entry)=>decode(entry));
-		                } else {
-		                    params[key] = decode(match);
-		                }
-		            }
-		        }
-		        return params;
-		    };
-		    // Wrap with safe matcher to handle parameter cleaning
-		    return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
-		}
-
-		
-	} (routeMatcher));
-	return routeMatcher;
-}
-
-export { requireRouteMatcher as __require };

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

@@ -1,272 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const routeRegex = require('../../../../../../../_virtual/route-regex.cjs');
-const constants = require('../../../../lib/constants.cjs');
-const interceptionRoutes = require('./interception-routes.cjs');
-const escapeRegexp = require('../../escape-regexp.cjs');
-const removeTrailingSlash = require('./remove-trailing-slash.cjs');
-const getDynamicParam = require('./get-dynamic-param.cjs');
-
-var hasRequiredRouteRegex;
-
-function requireRouteRegex () {
-	if (hasRequiredRouteRegex) return routeRegex.__exports;
-	hasRequiredRouteRegex = 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, {
-		    getNamedMiddlewareRegex: function() {
-		        return getNamedMiddlewareRegex;
-		    },
-		    getNamedRouteRegex: function() {
-		        return getNamedRouteRegex;
-		    },
-		    getRouteRegex: function() {
-		        return getRouteRegex;
-		    }
-		});
-		const _constants = constants.__require();
-		const _interceptionroutes = interceptionRoutes.__require();
-		const _escaperegexp = escapeRegexp.__require();
-		const _removetrailingslash = removeTrailingSlash.__require();
-		const _getdynamicparam = getDynamicParam.__require();
-		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}$`
-		    };
-		}
-
-		
-	} (routeRegex.__exports));
-	return routeRegex.__exports;
-}
-
-exports.__require = requireRouteRegex;