@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/server/send-payload.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    sendEtagResponse: null,
+    sendRenderResult: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    sendEtagResponse: function() {
+        return sendEtagResponse;
+    },
+    sendRenderResult: function() {
+        return sendRenderResult;
+    }
+});
+const _utils = require("../shared/lib/utils");
+const _etag = require("./lib/etag");
+const _fresh = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/fresh"));
+const _cachecontrol = require("./lib/cache-control");
+const _constants = require("../lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function sendEtagResponse(req, res, etag) {
+    if (etag) {
+        /**
+     * The server generating a 304 response MUST generate any of the
+     * following header fields that would have been sent in a 200 (OK)
+     * response to the same request: Cache-Control, Content-Location, Date,
+     * ETag, Expires, and Vary. https://tools.ietf.org/html/rfc7232#section-4.1
+     */ res.setHeader('ETag', etag);
+    }
+    if ((0, _fresh.default)(req.headers, {
+        etag
+    })) {
+        res.statusCode = 304;
+        res.end();
+        return true;
+    }
+    return false;
+}
+async function sendRenderResult({ req, res, result, generateEtags, poweredByHeader, cacheControl }) {
+    if ((0, _utils.isResSent)(res)) {
+        return;
+    }
+    if (poweredByHeader && result.contentType === _constants.HTML_CONTENT_TYPE_HEADER) {
+        res.setHeader('X-Powered-By', 'Next.js');
+    }
+    // If cache control is already set on the response we don't
+    // override it to allow users to customize it via next.config
+    if (cacheControl && !res.getHeader('Cache-Control')) {
+        res.setHeader('Cache-Control', (0, _cachecontrol.getCacheControlHeader)(cacheControl));
+    }
+    const payload = result.isDynamic ? null : result.toUnchunkedString();
+    if (generateEtags && payload !== null) {
+        const etag = (0, _etag.generateETag)(payload);
+        if (sendEtagResponse(req, res, etag)) {
+            return;
+        }
+    }
+    if (!res.getHeader('Content-Type') && result.contentType) {
+        res.setHeader('Content-Type', result.contentType);
+    }
+    if (payload) {
+        res.setHeader('Content-Length', Buffer.byteLength(payload));
+    }
+    if (req.method === 'HEAD') {
+        res.end(null);
+        return;
+    }
+    if (payload !== null) {
+        res.end(payload);
+        return;
+    }
+    // Pipe the render result to the response after we get a writer for it.
+    await result.pipeToNodeResponse(res);
+}
+
+//# sourceMappingURL=send-payload.js.map

package/webapp-dist/vendor/next/dist/server/send-response.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sendResponse", {
+    enumerable: true,
+    get: function() {
+        return sendResponse;
+    }
+});
+const _helpers = require("./base-http/helpers");
+const _pipereadable = require("./pipe-readable");
+const _utils = require("./web/utils");
+async function sendResponse(req, res, response, waitUntil) {
+    if (// The type check here ensures that `req` is correctly typed, and the
+    // environment variable check provides dead code elimination.
+    process.env.NEXT_RUNTIME !== 'edge' && (0, _helpers.isNodeNextResponse)(res)) {
+        var // Copy over the response headers.
+        _response_headers;
+        // Copy over the response status.
+        res.statusCode = response.status;
+        res.statusMessage = response.statusText;
+        // TODO: this is not spec-compliant behavior and we should not restrict
+        // headers that are allowed to appear many times.
+        //
+        // See:
+        // https://github.com/vercel/next.js/pull/70127
+        const headersWithMultipleValuesAllowed = [
+            // can add more headers to this list if needed
+            'set-cookie',
+            'www-authenticate',
+            'proxy-authenticate',
+            'vary'
+        ];
+        (_response_headers = response.headers) == null ? void 0 : _response_headers.forEach((value, name)=>{
+            // `x-middleware-set-cookie` is an internal header not needed for the response
+            if (name.toLowerCase() === 'x-middleware-set-cookie') {
+                return;
+            }
+            // The append handling is special cased for `set-cookie`.
+            if (name.toLowerCase() === 'set-cookie') {
+                // TODO: (wyattjoh) replace with native response iteration when we can upgrade undici
+                for (const cookie of (0, _utils.splitCookiesString)(value)){
+                    res.appendHeader(name, cookie);
+                }
+            } else {
+                // only append the header if it is either not present in the outbound response
+                // or if the header supports multiple values
+                const isHeaderPresent = typeof res.getHeader(name) !== 'undefined';
+                if (headersWithMultipleValuesAllowed.includes(name.toLowerCase()) || !isHeaderPresent) {
+                    res.appendHeader(name, value);
+                }
+            }
+        });
+        /**
+     * The response can't be directly piped to the underlying response. The
+     * following is duplicated from the edge runtime handler.
+     *
+     * See packages/next/server/next-server.ts
+     */ const { originalResponse } = res;
+        // A response body must not be sent for HEAD requests. See https://httpwg.org/specs/rfc9110.html#HEAD
+        if (response.body && req.method !== 'HEAD') {
+            await (0, _pipereadable.pipeToNodeResponse)(response.body, originalResponse, waitUntil);
+        } else {
+            originalResponse.end();
+        }
+    }
+}
+
+//# sourceMappingURL=send-response.js.map

package/webapp-dist/vendor/next/dist/server/serve-static.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getContentType: null,
+    getExtension: null,
+    serveStatic: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getContentType: function() {
+        return getContentType;
+    },
+    getExtension: function() {
+        return getExtension;
+    },
+    serveStatic: function() {
+        return serveStatic;
+    }
+});
+const _send = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/send"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// TODO: Remove this once "send" has updated the "mime", or next.js use custom version of "mime"
+// Although "mime" has already add avif in version 2.4.7, "send" is still using mime@1.6.0
+_send.default.mime.define({
+    'image/avif': [
+        'avif'
+    ],
+    'image/x-icns': [
+        'icns'
+    ],
+    'image/jxl': [
+        'jxl'
+    ],
+    'image/heic': [
+        'heic'
+    ]
+});
+function serveStatic(req, res, path, opts) {
+    return new Promise((resolve, reject)=>{
+        (0, _send.default)(req, path, opts).on('directory', ()=>{
+            // We don't allow directories to be read.
+            const err = Object.defineProperty(new Error('No directory access'), "__NEXT_ERROR_CODE", {
+                value: "E340",
+                enumerable: false,
+                configurable: true
+            });
+            err.code = 'ENOENT';
+            reject(err);
+        }).on('error', reject).pipe(res).on('finish', resolve);
+    });
+}
+const getContentType = 'getType' in _send.default.mime ? (extWithoutDot)=>_send.default.mime.getType(extWithoutDot) : (extWithoutDot)=>_send.default.mime.lookup(extWithoutDot);
+const getExtension = 'getExtension' in _send.default.mime ? (contentType)=>_send.default.mime.getExtension(contentType) : (contentType)=>_send.default.mime.extension(contentType);
+
+//# sourceMappingURL=serve-static.js.map

package/webapp-dist/vendor/next/dist/server/server-route-utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "stringifyQuery", {
+    enumerable: true,
+    get: function() {
+        return stringifyQuery;
+    }
+});
+const _requestmeta = require("./request-meta");
+const _querystring = require("querystring");
+const stringifyQuery = (req, query)=>{
+    const initialQuery = (0, _requestmeta.getRequestMeta)(req, 'initQuery') || {};
+    const initialQueryValues = Object.values(initialQuery);
+    return (0, _querystring.stringify)(query, undefined, undefined, {
+        encodeURIComponent (value) {
+            if (value in initialQuery || initialQueryValues.some((initialQueryVal)=>{
+                // `value` always refers to a query value, even if it's nested in an array
+                return Array.isArray(initialQueryVal) ? initialQueryVal.includes(value) : initialQueryVal === value;
+            })) {
+                // Encode keys and values from initial query
+                return encodeURIComponent(value);
+            }
+            return value;
+        }
+    });
+};
+
+//# sourceMappingURL=server-route-utils.js.map

package/webapp-dist/vendor/next/dist/server/server-utils.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getPreviouslyRevalidatedTags: null,
+    getServerUtils: null,
+    interpolateDynamicPath: null,
+    normalizeCdnUrl: null,
+    normalizeDynamicRouteParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getPreviouslyRevalidatedTags: function() {
+        return getPreviouslyRevalidatedTags;
+    },
+    getServerUtils: function() {
+        return getServerUtils;
+    },
+    interpolateDynamicPath: function() {
+        return interpolateDynamicPath;
+    },
+    normalizeCdnUrl: function() {
+        return normalizeCdnUrl;
+    },
+    normalizeDynamicRouteParams: function() {
+        return normalizeDynamicRouteParams;
+    }
+});
+const _normalizelocalepath = require("../shared/lib/i18n/normalize-locale-path");
+const _pathmatch = require("../shared/lib/router/utils/path-match");
+const _routeregex = require("../shared/lib/router/utils/route-regex");
+const _routematcher = require("../shared/lib/router/utils/route-matcher");
+const _preparedestination = require("../shared/lib/router/utils/prepare-destination");
+const _removetrailingslash = require("../shared/lib/router/utils/remove-trailing-slash");
+const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _constants = require("../lib/constants");
+const _utils = require("./web/utils");
+const _decodequerypathparameter = require("./lib/decode-query-path-parameter");
+const _url = require("../lib/url");
+const _formaturl = require("../shared/lib/router/utils/format-url");
+function filterInternalQuery(query, paramKeys) {
+    // this is used to pass query information in rewrites
+    // but should not be exposed in final query
+    delete query['nextInternalLocale'];
+    for(const key in query){
+        const isNextQueryPrefix = key !== _constants.NEXT_QUERY_PARAM_PREFIX && key.startsWith(_constants.NEXT_QUERY_PARAM_PREFIX);
+        const isNextInterceptionMarkerPrefix = key !== _constants.NEXT_INTERCEPTION_MARKER_PREFIX && key.startsWith(_constants.NEXT_INTERCEPTION_MARKER_PREFIX);
+        if (isNextQueryPrefix || isNextInterceptionMarkerPrefix || paramKeys.includes(key)) {
+            delete query[key];
+        }
+    }
+}
+function normalizeCdnUrl(req, paramKeys) {
+    // make sure to normalize req.url from CDNs to strip dynamic and rewrite
+    // params from the query which are added during routing
+    const _parsedUrl = (0, _url.parseReqUrl)(req.url);
+    // we can't normalize if we can't parse
+    if (!_parsedUrl) {
+        return req.url;
+    }
+    delete _parsedUrl.search;
+    filterInternalQuery(_parsedUrl.query, paramKeys);
+    req.url = (0, _formaturl.formatUrl)(_parsedUrl);
+}
+function interpolateDynamicPath(pathname, params, defaultRouteRegex) {
+    if (!defaultRouteRegex) return pathname;
+    for (const param of Object.keys(defaultRouteRegex.groups)){
+        const { optional, repeat } = defaultRouteRegex.groups[param];
+        let builtParam = `[${repeat ? '...' : ''}${param}]`;
+        if (optional) {
+            builtParam = `[${builtParam}]`;
+        }
+        let paramValue;
+        const value = params[param];
+        if (Array.isArray(value)) {
+            paramValue = value.map((v)=>v && encodeURIComponent(v)).join('/');
+        } else if (value) {
+            paramValue = encodeURIComponent(value);
+        } else {
+            paramValue = '';
+        }
+        if (paramValue || optional) {
+            pathname = pathname.replaceAll(builtParam, paramValue);
+        }
+    }
+    return pathname;
+}
+function normalizeDynamicRouteParams(query, defaultRouteRegex, defaultRouteMatches, ignoreMissingOptional) {
+    let hasValidParams = true;
+    let params = {};
+    for (const key of Object.keys(defaultRouteRegex.groups)){
+        let value = query[key];
+        if (typeof value === 'string') {
+            value = (0, _apppaths.normalizeRscURL)(value);
+        } else if (Array.isArray(value)) {
+            value = value.map(_apppaths.normalizeRscURL);
+        }
+        // if the value matches the default value we can't rely
+        // on the parsed params, this is used to signal if we need
+        // to parse x-now-route-matches or not
+        const defaultValue = defaultRouteMatches[key];
+        const isOptional = defaultRouteRegex.groups[key].optional;
+        const isDefaultValue = Array.isArray(defaultValue) ? defaultValue.some((defaultVal)=>{
+            return Array.isArray(value) ? value.some((val)=>val.includes(defaultVal)) : value == null ? void 0 : value.includes(defaultVal);
+        }) : value == null ? void 0 : value.includes(defaultValue);
+        if (isDefaultValue || typeof value === 'undefined' && !(isOptional && ignoreMissingOptional)) {
+            return {
+                params: {},
+                hasValidParams: false
+            };
+        }
+        // non-provided optional values should be undefined so normalize
+        // them to undefined
+        if (isOptional && (!value || Array.isArray(value) && value.length === 1 && // fallback optional catch-all SSG pages have
+        // [[...paramName]] for the root path on Vercel
+        (value[0] === 'index' || value[0] === `[[...${key}]]`) || value === 'index' || value === `[[...${key}]]`)) {
+            value = undefined;
+            delete query[key];
+        }
+        // query values from the proxy aren't already split into arrays
+        // so make sure to normalize catch-all values
+        if (value && typeof value === 'string' && defaultRouteRegex.groups[key].repeat) {
+            value = value.split('/');
+        }
+        if (value) {
+            params[key] = value;
+        }
+    }
+    return {
+        params,
+        hasValidParams
+    };
+}
+function getServerUtils({ page, i18n, basePath, rewrites, pageIsDynamic, trailingSlash, caseSensitive }) {
+    let defaultRouteRegex;
+    let dynamicRouteMatcher;
+    let defaultRouteMatches;
+    if (pageIsDynamic) {
+        defaultRouteRegex = (0, _routeregex.getNamedRouteRegex)(page, {
+            prefixRouteKeys: false
+        });
+        dynamicRouteMatcher = (0, _routematcher.getRouteMatcher)(defaultRouteRegex);
+        defaultRouteMatches = dynamicRouteMatcher(page);
+    }
+    function handleRewrites(req, parsedUrl) {
+        // Here we deep clone the parsedUrl to avoid mutating the original. We also
+        // cast this to a mutable type so we can mutate it within this scope.
+        const rewrittenParsedUrl = structuredClone(parsedUrl);
+        const rewriteParams = {};
+        let fsPathname = rewrittenParsedUrl.pathname;
+        const matchesPage = ()=>{
+            const fsPathnameNoSlash = (0, _removetrailingslash.removeTrailingSlash)(fsPathname || '');
+            return fsPathnameNoSlash === (0, _removetrailingslash.removeTrailingSlash)(page) || (dynamicRouteMatcher == null ? void 0 : dynamicRouteMatcher(fsPathnameNoSlash));
+        };
+        const checkRewrite = (rewrite)=>{
+            const matcher = (0, _pathmatch.getPathMatch)(rewrite.source + (trailingSlash ? '(/)?' : ''), {
+                removeUnnamedParams: true,
+                strict: true,
+                sensitive: !!caseSensitive
+            });
+            if (!rewrittenParsedUrl.pathname) return false;
+            let params = matcher(rewrittenParsedUrl.pathname);
+            if ((rewrite.has || rewrite.missing) && params) {
+                const hasParams = (0, _preparedestination.matchHas)(req, rewrittenParsedUrl.query, rewrite.has, rewrite.missing);
+                if (hasParams) {
+                    Object.assign(params, hasParams);
+                } else {
+                    params = false;
+                }
+            }
+            if (params) {
+                const { parsedDestination, destQuery } = (0, _preparedestination.prepareDestination)({
+                    appendParamsToQuery: true,
+                    destination: rewrite.destination,
+                    params: params,
+                    query: rewrittenParsedUrl.query
+                });
+                // if the rewrite destination is external break rewrite chain
+                if (parsedDestination.protocol) {
+                    return true;
+                }
+                Object.assign(rewriteParams, destQuery, params);
+                Object.assign(rewrittenParsedUrl.query, parsedDestination.query);
+                delete parsedDestination.query;
+                Object.assign(rewrittenParsedUrl, parsedDestination);
+                fsPathname = rewrittenParsedUrl.pathname;
+                if (!fsPathname) return false;
+                if (basePath) {
+                    fsPathname = fsPathname.replace(new RegExp(`^${basePath}`), '') || '/';
+                }
+                if (i18n) {
+                    const result = (0, _normalizelocalepath.normalizeLocalePath)(fsPathname, i18n.locales);
+                    fsPathname = result.pathname;
+                    rewrittenParsedUrl.query.nextInternalLocale = result.detectedLocale || params.nextInternalLocale;
+                }
+                if (fsPathname === page) {
+                    return true;
+                }
+                if (pageIsDynamic && dynamicRouteMatcher) {
+                    const dynamicParams = dynamicRouteMatcher(fsPathname);
+                    if (dynamicParams) {
+                        rewrittenParsedUrl.query = {
+                            ...rewrittenParsedUrl.query,
+                            ...dynamicParams
+                        };
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        for (const rewrite of rewrites.beforeFiles || []){
+            checkRewrite(rewrite);
+        }
+        if (fsPathname !== page) {
+            let finished = false;
+            for (const rewrite of rewrites.afterFiles || []){
+                finished = checkRewrite(rewrite);
+                if (finished) break;
+            }
+            if (!finished && !matchesPage()) {
+                for (const rewrite of rewrites.fallback || []){
+                    finished = checkRewrite(rewrite);
+                    if (finished) break;
+                }
+            }
+        }
+        return {
+            rewriteParams,
+            rewrittenParsedUrl
+        };
+    }
+    function getParamsFromRouteMatches(routeMatchesHeader) {
+        // If we don't have a default route regex, we can't get params from route
+        // matches
+        if (!defaultRouteRegex) return null;
+        const { groups, routeKeys } = defaultRouteRegex;
+        const matcher = (0, _routematcher.getRouteMatcher)({
+            re: {
+                // Simulate a RegExp match from the \`req.url\` input
+                exec: (str)=>{
+                    // Normalize all the prefixed query params.
+                    const obj = Object.fromEntries(new URLSearchParams(str));
+                    for (const [key, value] of Object.entries(obj)){
+                        const normalizedKey = (0, _utils.normalizeNextQueryParam)(key);
+                        if (!normalizedKey) continue;
+                        obj[normalizedKey] = value;
+                        delete obj[key];
+                    }
+                    // Use all the named route keys.
+                    const result = {};
+                    for (const keyName of Object.keys(routeKeys)){
+                        const paramName = routeKeys[keyName];
+                        // If this param name is not a valid parameter name, then skip it.
+                        if (!paramName) continue;
+                        const group = groups[paramName];
+                        const value = obj[keyName];
+                        // When we're missing a required param, we can't match the route.
+                        if (!group.optional && !value) return null;
+                        result[group.pos] = value;
+                    }
+                    return result;
+                }
+            },
+            groups
+        });
+        const routeMatches = matcher(routeMatchesHeader);
+        if (!routeMatches) return null;
+        return routeMatches;
+    }
+    function normalizeQueryParams(query, routeParamKeys) {
+        // this is used to pass query information in rewrites
+        // but should not be exposed in final query
+        delete query['nextInternalLocale'];
+        for (const [key, value] of Object.entries(query)){
+            const normalizedKey = (0, _utils.normalizeNextQueryParam)(key);
+            if (!normalizedKey) continue;
+            // Remove the prefixed key from the query params because we want
+            // to consume it for the dynamic route matcher.
+            delete query[key];
+            routeParamKeys.add(normalizedKey);
+            if (typeof value === 'undefined') continue;
+            query[normalizedKey] = Array.isArray(value) ? value.map((v)=>(0, _decodequerypathparameter.decodeQueryPathParameter)(v)) : (0, _decodequerypathparameter.decodeQueryPathParameter)(value);
+        }
+    }
+    return {
+        handleRewrites,
+        defaultRouteRegex,
+        dynamicRouteMatcher,
+        defaultRouteMatches,
+        normalizeQueryParams,
+        getParamsFromRouteMatches,
+        /**
+     * Normalize dynamic route params.
+     *
+     * @param query - The query params to normalize.
+     * @param ignoreMissingOptional - Whether to ignore missing optional params.
+     * @returns The normalized params and whether they are valid.
+     */ normalizeDynamicRouteParams: (query, ignoreMissingOptional)=>{
+            if (!defaultRouteRegex || !defaultRouteMatches) {
+                return {
+                    params: {},
+                    hasValidParams: false
+                };
+            }
+            return normalizeDynamicRouteParams(query, defaultRouteRegex, defaultRouteMatches, ignoreMissingOptional);
+        },
+        normalizeCdnUrl: (req, paramKeys)=>normalizeCdnUrl(req, paramKeys),
+        interpolateDynamicPath: (pathname, params)=>interpolateDynamicPath(pathname, params, defaultRouteRegex),
+        filterInternalQuery: (query, paramKeys)=>filterInternalQuery(query, paramKeys)
+    };
+}
+function getPreviouslyRevalidatedTags(headers, previewModeId) {
+    return typeof headers[_constants.NEXT_CACHE_REVALIDATED_TAGS_HEADER] === 'string' && headers[_constants.NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER] === previewModeId ? headers[_constants.NEXT_CACHE_REVALIDATED_TAGS_HEADER].split(',') : [];
+}
+
+//# sourceMappingURL=server-utils.js.map

package/webapp-dist/vendor/next/dist/server/setup-http-agent-env.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "setHttpClientAndAgentOptions", {
+    enumerable: true,
+    get: function() {
+        return setHttpClientAndAgentOptions;
+    }
+});
+const _http = require("http");
+const _https = require("https");
+function setHttpClientAndAgentOptions(config) {
+    if (globalThis.__NEXT_HTTP_AGENT) {
+        // We only need to assign once because we want
+        // to reuse the same agent for all requests.
+        return;
+    }
+    if (!config) {
+        throw Object.defineProperty(new Error('Expected config.httpAgentOptions to be an object'), "__NEXT_ERROR_CODE", {
+            value: "E204",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    globalThis.__NEXT_HTTP_AGENT_OPTIONS = config.httpAgentOptions;
+    globalThis.__NEXT_HTTP_AGENT = new _http.Agent(config.httpAgentOptions);
+    globalThis.__NEXT_HTTPS_AGENT = new _https.Agent(config.httpAgentOptions);
+}
+
+//# sourceMappingURL=setup-http-agent-env.js.map