failproofai 0.0.1-beta.1

package/.next/standalone/node_modules/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/.next/standalone/node_modules/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/.next/standalone/node_modules/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/.next/standalone/node_modules/next/dist/shared/lib/router/utils/parse-loader-tree.js

@@ -0,0 +1,30 @@
+"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, staticSiblings] = 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,
+        staticSiblings
+    };
+}
+
+//# sourceMappingURL=parse-loader-tree.js.map

package/.next/standalone/node_modules/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/.next/standalone/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.js

@@ -0,0 +1,43 @@
+"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 } = url.startsWith('/') ? // See https://nodejs.org/api/http.html#messageurl
+    // Not using `origin` to support other protocols
+    new URL(`${resolvedBase.protocol}//${resolvedBase.host}${url}`) : 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 {
+        auth: null,
+        host: null,
+        hostname: null,
+        pathname,
+        port: null,
+        protocol: null,
+        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: null
+    };
+}
+
+//# sourceMappingURL=parse-relative-url.js.map

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

@@ -0,0 +1,38 @@
+"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);
+    const username = parsedURL.username;
+    const password = parsedURL.password;
+    const auth = username ? password ? `${username}:${password}` : username : null;
+    const pathname = parsedURL.pathname;
+    const search = parsedURL.search;
+    return {
+        auth,
+        hash: parsedURL.hash,
+        hostname: parsedURL.hostname,
+        href: parsedURL.href,
+        pathname,
+        port: parsedURL.port,
+        protocol: parsedURL.protocol,
+        query: (0, _querystring.searchParamsToUrlQuery)(parsedURL.searchParams),
+        search,
+        origin: parsedURL.origin,
+        slashes: parsedURL.href.slice(parsedURL.protocol.length, parsedURL.protocol.length + 2) === '//'
+    };
+}
+
+//# sourceMappingURL=parse-url.js.map

package/.next/standalone/node_modules/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/.next/standalone/node_modules/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/.next/standalone/node_modules/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