@obsfx/trekker 0.1.7 → 0.1.9

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PARAMETER_PATTERN: null,
+    getDynamicParam: null,
+    interpolateParallelRouteParams: null,
+    parseMatchedParameter: null,
+    parseParameter: null
+});
+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 = require("../../invariant-error");
+const _parseloadertree = require("./parse-loader-tree");
+const _app = require("../routes/app");
+const _resolveparamvalue = require("./resolve-param-value");
+/**
+ * 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
+        }
+    ];
+    // Parse the route from the provided page path.
+    const route = (0, _app.parseAppRoute)(pagePath, true);
+    while(stack.length > 0){
+        const { tree, depth } = stack.pop();
+        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        const appSegment = (0, _app.parseAppRouteSegment)(segment);
+        if (appSegment?.type === 'dynamic' && !interpolated.hasOwnProperty(appSegment.param.paramName) && // 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(appSegment.param.paramName)) {
+            const { paramName, paramType } = appSegment.param;
+            const paramValue = (0, _resolveparamvalue.resolveParamValue)(paramName, paramType, depth, route, interpolated);
+            if (paramValue !== undefined) {
+                interpolated[paramName] = paramValue;
+            } else if (paramType !== 'optional-catchall') {
+                throw Object.defineProperty(new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`), "__NEXT_ERROR_CODE", {
+                    value: "E932",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        }
+        // Calculate next depth - increment if this is not a route group and not empty
+        let nextDepth = depth;
+        if (appSegment && appSegment.type !== 'route-group' && appSegment.type !== 'parallel-route') {
+            nextDepth++;
+        }
+        // Add all parallel routes to the stack for processing
+        for (const parallelRoute of Object.values(parallelRoutes)){
+            stack.push({
+                tree: parallelRoute,
+                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
+    };
+}
+
+//# sourceMappingURL=get-dynamic-param.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/get-next-pathname-info.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNextPathnameInfo", {
+    enumerable: true,
+    get: function() {
+        return getNextPathnameInfo;
+    }
+});
+const _normalizelocalepath = require("../../i18n/normalize-locale-path");
+const _removepathprefix = require("./remove-path-prefix");
+const _pathhasprefix = require("./path-has-prefix");
+function getNextPathnameInfo(pathname, options) {
+    const { basePath, i18n, trailingSlash } = options.nextConfig ?? {};
+    const info = {
+        pathname,
+        trailingSlash: pathname !== '/' ? pathname.endsWith('/') : trailingSlash
+    };
+    if (basePath && (0, _pathhasprefix.pathHasPrefix)(info.pathname, basePath)) {
+        info.pathname = (0, _removepathprefix.removePathPrefix)(info.pathname, basePath);
+        info.basePath = basePath;
+    }
+    let pathnameNoDataPrefix = info.pathname;
+    if (info.pathname.startsWith('/_next/data/') && info.pathname.endsWith('.json')) {
+        const paths = info.pathname.replace(/^\/_next\/data\//, '').replace(/\.json$/, '').split('/');
+        const buildId = paths[0];
+        info.buildId = buildId;
+        pathnameNoDataPrefix = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/';
+        // update pathname with normalized if enabled although
+        // we use normalized to populate locale info still
+        if (options.parseData === true) {
+            info.pathname = pathnameNoDataPrefix;
+        }
+    }
+    // If provided, use the locale route normalizer to detect the locale instead
+    // of the function below.
+    if (i18n) {
+        let result = options.i18nProvider ? options.i18nProvider.analyze(info.pathname) : (0, _normalizelocalepath.normalizeLocalePath)(info.pathname, i18n.locales);
+        info.locale = result.detectedLocale;
+        info.pathname = result.pathname ?? info.pathname;
+        if (!result.detectedLocale && info.buildId) {
+            result = options.i18nProvider ? options.i18nProvider.analyze(pathnameNoDataPrefix) : (0, _normalizelocalepath.normalizeLocalePath)(pathnameNoDataPrefix, i18n.locales);
+            if (result.detectedLocale) {
+                info.locale = result.detectedLocale;
+            }
+        }
+    }
+    return info;
+}
+
+//# sourceMappingURL=get-next-pathname-info.js.map

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

@@ -0,0 +1,25 @@
+// Translate a pages asset path (relative from a common prefix) back into its logical route
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, // "asset path" being its javascript file, data file, prerendered html,...
+"default", {
+    enumerable: true,
+    get: function() {
+        return getRouteFromAssetPath;
+    }
+});
+const _isdynamic = require("./is-dynamic");
+function getRouteFromAssetPath(assetPath, ext = '') {
+    assetPath = assetPath.replace(/\\/g, '/');
+    assetPath = ext && assetPath.endsWith(ext) ? assetPath.slice(0, -ext.length) : assetPath;
+    if (assetPath.startsWith('/index/') && !(0, _isdynamic.isDynamicRoute)(assetPath)) {
+        assetPath = assetPath.slice(6);
+    } else if (assetPath === '/index') {
+        assetPath = '/';
+    }
+    return assetPath;
+}
+
+//# sourceMappingURL=get-route-from-asset-path.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/get-segment-param.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getParamProperties: null,
+    getSegmentParam: null,
+    isCatchAll: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getParamProperties: function() {
+        return getParamProperties;
+    },
+    getSegmentParam: function() {
+        return getSegmentParam;
+    },
+    isCatchAll: function() {
+        return isCatchAll;
+    }
+});
+const _interceptionroutes = require("./interception-routes");
+function getSegmentParam(segment) {
+    const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((marker)=>segment.startsWith(marker));
+    // if an interception marker is part of the path segment, we need to jump ahead
+    // to the relevant portion for param parsing
+    if (interceptionMarker) {
+        segment = segment.slice(interceptionMarker.length);
+    }
+    if (segment.startsWith('[[...') && segment.endsWith(']]')) {
+        return {
+            // TODO-APP: Optional catchall does not currently work with parallel routes,
+            // so for now aren't handling a potential interception marker.
+            paramType: 'optional-catchall',
+            paramName: segment.slice(5, -2)
+        };
+    }
+    if (segment.startsWith('[...') && segment.endsWith(']')) {
+        return {
+            paramType: interceptionMarker ? `catchall-intercepted-${interceptionMarker}` : 'catchall',
+            paramName: segment.slice(4, -1)
+        };
+    }
+    if (segment.startsWith('[') && segment.endsWith(']')) {
+        return {
+            paramType: interceptionMarker ? `dynamic-intercepted-${interceptionMarker}` : 'dynamic',
+            paramName: segment.slice(1, -1)
+        };
+    }
+    return null;
+}
+function isCatchAll(type) {
+    return type === 'catchall' || type === 'catchall-intercepted-(..)(..)' || type === 'catchall-intercepted-(.)' || type === 'catchall-intercepted-(..)' || type === 'catchall-intercepted-(...)' || type === 'optional-catchall';
+}
+function getParamProperties(paramType) {
+    let repeat = false;
+    let optional = false;
+    switch(paramType){
+        case 'catchall':
+        case 'catchall-intercepted-(..)(..)':
+        case 'catchall-intercepted-(.)':
+        case 'catchall-intercepted-(..)':
+        case 'catchall-intercepted-(...)':
+            repeat = true;
+            break;
+        case 'optional-catchall':
+            repeat = true;
+            optional = true;
+            break;
+        case 'dynamic':
+        case 'dynamic-intercepted-(..)(..)':
+        case 'dynamic-intercepted-(.)':
+        case 'dynamic-intercepted-(..)':
+        case 'dynamic-intercepted-(...)':
+            break;
+        default:
+            paramType;
+    }
+    return {
+        repeat,
+        optional
+    };
+}
+
+//# sourceMappingURL=get-segment-param.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/html-bots.js

@@ -0,0 +1,17 @@
+// This regex contains the bots that we need to do a blocking render for and can't safely stream the response
+// due to how they parse the DOM. For example, they might explicitly check for metadata in the `head` tag, so we can't stream metadata tags after the `head` was sent.
+// Note: The pattern [\w-]+-Google captures all Google crawlers with "-Google" suffix (e.g., Mediapartners-Google, AdsBot-Google, Storebot-Google)
+// as well as crawlers starting with "Google-" (e.g., Google-PageRenderer, Google-InspectionTool)
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HTML_LIMITED_BOT_UA_RE", {
+    enumerable: true,
+    get: function() {
+        return HTML_LIMITED_BOT_UA_RE;
+    }
+});
+const HTML_LIMITED_BOT_UA_RE = /[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight/i;
+
+//# sourceMappingURL=html-bots.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSortedRouteObjects: null,
+    getSortedRoutes: null,
+    isDynamicRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getSortedRouteObjects: function() {
+        return _sortedroutes.getSortedRouteObjects;
+    },
+    getSortedRoutes: function() {
+        return _sortedroutes.getSortedRoutes;
+    },
+    isDynamicRoute: function() {
+        return _isdynamic.isDynamicRoute;
+    }
+});
+const _sortedroutes = require("./sorted-routes");
+const _isdynamic = require("./is-dynamic");
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/interception-prefix-from-param-type.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "interceptionPrefixFromParamType", {
+    enumerable: true,
+    get: function() {
+        return interceptionPrefixFromParamType;
+    }
+});
+function interceptionPrefixFromParamType(paramType) {
+    switch(paramType){
+        case 'catchall-intercepted-(..)(..)':
+        case 'dynamic-intercepted-(..)(..)':
+            return '(..)(..)';
+        case 'catchall-intercepted-(.)':
+        case 'dynamic-intercepted-(.)':
+            return '(.)';
+        case 'catchall-intercepted-(..)':
+        case 'dynamic-intercepted-(..)':
+            return '(..)';
+        case 'catchall-intercepted-(...)':
+        case 'dynamic-intercepted-(...)':
+            return '(...)';
+        case 'catchall':
+        case 'dynamic':
+        case 'optional-catchall':
+        default:
+            return null;
+    }
+}
+
+//# sourceMappingURL=interception-prefix-from-param-type.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/interception-routes.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    INTERCEPTION_ROUTE_MARKERS: null,
+    extractInterceptionRouteInformation: null,
+    isInterceptionRouteAppPath: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INTERCEPTION_ROUTE_MARKERS: function() {
+        return INTERCEPTION_ROUTE_MARKERS;
+    },
+    extractInterceptionRouteInformation: function() {
+        return extractInterceptionRouteInformation;
+    },
+    isInterceptionRouteAppPath: function() {
+        return isInterceptionRouteAppPath;
+    }
+});
+const _apppaths = require("./app-paths");
+const INTERCEPTION_ROUTE_MARKERS = [
+    '(..)(..)',
+    '(.)',
+    '(..)',
+    '(...)'
+];
+function isInterceptionRouteAppPath(path) {
+    // TODO-APP: add more serious validation
+    return path.split('/').find((segment)=>INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m))) !== undefined;
+}
+function extractInterceptionRouteInformation(path) {
+    let interceptingRoute;
+    let marker;
+    let interceptedRoute;
+    for (const segment of path.split('/')){
+        marker = INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+        if (marker) {
+            ;
+            [interceptingRoute, interceptedRoute] = path.split(marker, 2);
+            break;
+        }
+    }
+    if (!interceptingRoute || !marker || !interceptedRoute) {
+        throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`), "__NEXT_ERROR_CODE", {
+            value: "E269",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute) // normalize the path, e.g. /(blog)/feed -> /feed
+    ;
+    switch(marker){
+        case '(.)':
+            // (.) indicates that we should match with sibling routes, so we just need to append the intercepted route to the intercepting route
+            if (interceptingRoute === '/') {
+                interceptedRoute = `/${interceptedRoute}`;
+            } else {
+                interceptedRoute = interceptingRoute + '/' + interceptedRoute;
+            }
+            break;
+        case '(..)':
+            // (..) indicates that we should match at one level up, so we need to remove the last segment of the intercepting route
+            if (interceptingRoute === '/') {
+                throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`), "__NEXT_ERROR_CODE", {
+                    value: "E207",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            interceptedRoute = interceptingRoute.split('/').slice(0, -1).concat(interceptedRoute).join('/');
+            break;
+        case '(...)':
+            // (...) will match the route segment in the root directory, so we need to use the root directory to prepend the intercepted route
+            interceptedRoute = '/' + interceptedRoute;
+            break;
+        case '(..)(..)':
+            // (..)(..) indicates that we should match at two levels up, so we need to remove the last two segments of the intercepting route
+            const splitInterceptingRoute = interceptingRoute.split('/');
+            if (splitInterceptingRoute.length <= 2) {
+                throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`), "__NEXT_ERROR_CODE", {
+                    value: "E486",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join('/');
+            break;
+        default:
+            throw Object.defineProperty(new Error('Invariant: unexpected marker'), "__NEXT_ERROR_CODE", {
+                value: "E112",
+                enumerable: false,
+                configurable: true
+            });
+    }
+    return {
+        interceptingRoute,
+        interceptedRoute
+    };
+}
+
+//# sourceMappingURL=interception-routes.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/is-bot.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HTML_LIMITED_BOT_UA_RE: null,
+    HTML_LIMITED_BOT_UA_RE_STRING: null,
+    getBotType: null,
+    isBot: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HTML_LIMITED_BOT_UA_RE: function() {
+        return _htmlbots.HTML_LIMITED_BOT_UA_RE;
+    },
+    HTML_LIMITED_BOT_UA_RE_STRING: function() {
+        return HTML_LIMITED_BOT_UA_RE_STRING;
+    },
+    getBotType: function() {
+        return getBotType;
+    },
+    isBot: function() {
+        return isBot;
+    }
+});
+const _htmlbots = require("./html-bots");
+// Bot crawler that will spin up a headless browser and execute JS.
+// Only the main Googlebot search crawler executes JavaScript, not other Google crawlers.
+// x-ref: https://developers.google.com/search/docs/crawling-indexing/google-common-crawlers
+// This regex specifically matches "Googlebot" but NOT "Mediapartners-Google", "AdsBot-Google", etc.
+const HEADLESS_BROWSER_BOT_UA_RE = /Googlebot(?!-)|Googlebot$/i;
+const HTML_LIMITED_BOT_UA_RE_STRING = _htmlbots.HTML_LIMITED_BOT_UA_RE.source;
+function isDomBotUA(userAgent) {
+    return HEADLESS_BROWSER_BOT_UA_RE.test(userAgent);
+}
+function isHtmlLimitedBotUA(userAgent) {
+    return _htmlbots.HTML_LIMITED_BOT_UA_RE.test(userAgent);
+}
+function isBot(userAgent) {
+    return isDomBotUA(userAgent) || isHtmlLimitedBotUA(userAgent);
+}
+function getBotType(userAgent) {
+    if (isDomBotUA(userAgent)) {
+        return 'dom';
+    }
+    if (isHtmlLimitedBotUA(userAgent)) {
+        return 'html';
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=is-bot.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/is-dynamic.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isDynamicRoute", {
+    enumerable: true,
+    get: function() {
+        return isDynamicRoute;
+    }
+});
+const _interceptionroutes = require("./interception-routes");
+// Identify /.*[param].*/ in route string
+const TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+// Identify /[param]/ in route string
+const TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/;
+function isDynamicRoute(route, strict = true) {
+    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(route)) {
+        route = (0, _interceptionroutes.extractInterceptionRouteInformation)(route).interceptedRoute;
+    }
+    if (strict) {
+        return TEST_STRICT_ROUTE.test(route);
+    }
+    return TEST_ROUTE.test(route);
+}
+
+//# sourceMappingURL=is-dynamic.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/middleware-route-matcher.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getMiddlewareRouteMatcher", {
+    enumerable: true,
+    get: function() {
+        return getMiddlewareRouteMatcher;
+    }
+});
+const _preparedestination = require("./prepare-destination");
+function getMiddlewareRouteMatcher(matchers) {
+    return (pathname, req, query)=>{
+        for (const matcher of matchers){
+            const routeMatch = new RegExp(matcher.regexp).exec(pathname);
+            if (!routeMatch) {
+                continue;
+            }
+            if (matcher.has || matcher.missing) {
+                const hasParams = (0, _preparedestination.matchHas)(req, query, matcher.has, matcher.missing);
+                if (!hasParams) {
+                    continue;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+}
+
+//# sourceMappingURL=middleware-route-matcher.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/parse-loader-tree.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseLoaderTree", {
+    enumerable: true,
+    get: function() {
+        return parseLoaderTree;
+    }
+});
+const _segment = require("../../segment");
+function parseLoaderTree(tree) {
+    const [segment, parallelRoutes, modules] = tree;
+    const { layout, template } = modules;
+    let { page } = modules;
+    // a __DEFAULT__ segment means that this route didn't match any of the
+    // segments in the route, so we should use the default page
+    page = segment === _segment.DEFAULT_SEGMENT_KEY ? modules.defaultPage : page;
+    const conventionPath = layout?.[1] || template?.[1] || page?.[1];
+    return {
+        page,
+        segment,
+        modules,
+        /* it can be either layout / template / page */ conventionPath,
+        parallelRoutes
+    };
+}
+
+//# sourceMappingURL=parse-loader-tree.js.map