@obsfx/trekker 0.1.7 → 0.1.9

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

@@ -0,0 +1,33 @@
+/**
+ * Given a path this function will find the pathname, query and hash and return
+ * them. This is useful to parse full paths on the client side.
+ * @param path A path to parse e.g. /foo/bar?id=1#hash
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parsePath", {
+    enumerable: true,
+    get: function() {
+        return parsePath;
+    }
+});
+function parsePath(path) {
+    const hashIndex = path.indexOf('#');
+    const queryIndex = path.indexOf('?');
+    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+    if (hasQuery || hashIndex > -1) {
+        return {
+            pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+            query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : '',
+            hash: hashIndex > -1 ? path.slice(hashIndex) : ''
+        };
+    }
+    return {
+        pathname: path,
+        query: '',
+        hash: ''
+    };
+}
+
+//# sourceMappingURL=parse-path.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/parse-relative-url.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseRelativeUrl", {
+    enumerable: true,
+    get: function() {
+        return parseRelativeUrl;
+    }
+});
+const _utils = require("../../utils");
+const _querystring = require("./querystring");
+function parseRelativeUrl(url, base, parseQuery = true) {
+    const globalBase = new URL(typeof window === 'undefined' ? 'http://n' : (0, _utils.getLocationOrigin)());
+    const resolvedBase = base ? new URL(base, globalBase) : url.startsWith('.') ? new URL(typeof window === 'undefined' ? 'http://n' : window.location.href) : globalBase;
+    const { pathname, searchParams, search, hash, href, origin } = new URL(url, resolvedBase);
+    if (origin !== globalBase.origin) {
+        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
+            value: "E159",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return {
+        pathname,
+        query: parseQuery ? (0, _querystring.searchParamsToUrlQuery)(searchParams) : undefined,
+        search,
+        hash,
+        href: href.slice(origin.length),
+        // We don't know for relative URLs at this point since we set a custom, internal
+        // base that isn't surfaced to users.
+        slashes: undefined
+    };
+}
+
+//# sourceMappingURL=parse-relative-url.js.map

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseUrl", {
+    enumerable: true,
+    get: function() {
+        return parseUrl;
+    }
+});
+const _querystring = require("./querystring");
+const _parserelativeurl = require("./parse-relative-url");
+function parseUrl(url) {
+    if (url.startsWith('/')) {
+        return (0, _parserelativeurl.parseRelativeUrl)(url);
+    }
+    const parsedURL = new URL(url);
+    return {
+        hash: parsedURL.hash,
+        hostname: parsedURL.hostname,
+        href: parsedURL.href,
+        pathname: parsedURL.pathname,
+        port: parsedURL.port,
+        protocol: parsedURL.protocol,
+        query: (0, _querystring.searchParamsToUrlQuery)(parsedURL.searchParams),
+        search: parsedURL.search,
+        origin: parsedURL.origin,
+        slashes: parsedURL.href.slice(parsedURL.protocol.length, parsedURL.protocol.length + 2) === '//'
+    };
+}
+
+//# sourceMappingURL=parse-url.js.map

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/path-has-prefix.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pathHasPrefix", {
+    enumerable: true,
+    get: function() {
+        return pathHasPrefix;
+    }
+});
+const _parsepath = require("./parse-path");
+function pathHasPrefix(path, prefix) {
+    if (typeof path !== 'string') {
+        return false;
+    }
+    const { pathname } = (0, _parsepath.parsePath)(path);
+    return pathname === prefix || pathname.startsWith(prefix + '/');
+}
+
+//# sourceMappingURL=path-has-prefix.js.map

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPathMatch", {
+    enumerable: true,
+    get: function() {
+        return getPathMatch;
+    }
+});
+const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
+function getPathMatch(path, options) {
+    const keys = [];
+    const regexp = (0, _pathtoregexp.pathToRegexp)(path, keys, {
+        delimiter: '/',
+        sensitive: typeof options?.sensitive === 'boolean' ? options.sensitive : false,
+        strict: options?.strict
+    });
+    const matcher = (0, _pathtoregexp.regexpToFunction)(options?.regexModifier ? new RegExp(options.regexModifier(regexp.source), regexp.flags) : regexp, keys);
+    /**
+   * A matcher function that will check if a given pathname matches the path
+   * given in the builder function. When the path does not match it will return
+   * `false` but if it does it will return an object with the matched params
+   * merged with the params provided in the second argument.
+   */ return (pathname, params)=>{
+        // If no pathname is provided it's not a match.
+        if (typeof pathname !== 'string') return false;
+        const match = matcher(pathname);
+        // If the path did not match `false` will be returned.
+        if (!match) return false;
+        /**
+     * If unnamed params are not allowed they must be removed from
+     * the matched parameters. path-to-regexp uses "string" for named and
+     * "number" for unnamed parameters.
+     */ if (options?.removeUnnamedParams) {
+            for (const key of keys){
+                if (typeof key.name === 'number') {
+                    delete match.params[key.name];
+                }
+            }
+        }
+        return {
+            ...params,
+            ...match.params
+        };
+    };
+}
+
+//# sourceMappingURL=path-match.js.map

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

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

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

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

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

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

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/remove-path-prefix.js

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

package/webapp-dist/vendor/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -0,0 +1,21 @@
+/**
+ * Removes the trailing slash for a given route or page path. Preserves the
+ * root page. Examples:
+ *   - `/foo/bar/` -> `/foo/bar`
+ *   - `/foo/bar` -> `/foo/bar`
+ *   - `/` -> `/`
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeTrailingSlash", {
+    enumerable: true,
+    get: function() {
+        return removeTrailingSlash;
+    }
+});
+function removeTrailingSlash(route) {
+    return route.replace(/\/$/, '') || '/';
+}
+
+//# sourceMappingURL=remove-trailing-slash.js.map