fixed version control heatmap and activity

.next/standalone/node_modules/next/dist/server/future/helpers/i18n-provider.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "I18NProvider", {
+    enumerable: true,
+    get: function() {
+        return I18NProvider;
+    }
+});
+class I18NProvider {
+    constructor(config){
+        var _config_domains;
+        this.config = config;
+        if (!config.locales.length) {
+            throw new Error("Invariant: No locales provided");
+        }
+        this.lowerCaseLocales = config.locales.map((locale)=>locale.toLowerCase());
+        this.lowerCaseDomains = (_config_domains = config.domains) == null ? void 0 : _config_domains.map((domainLocale)=>{
+            var _domainLocale_locales;
+            const domain = domainLocale.domain.toLowerCase();
+            return {
+                defaultLocale: domainLocale.defaultLocale.toLowerCase(),
+                hostname: domain.split(":", 1)[0],
+                domain,
+                locales: (_domainLocale_locales = domainLocale.locales) == null ? void 0 : _domainLocale_locales.map((locale)=>locale.toLowerCase()),
+                http: domainLocale.http
+            };
+        });
+    }
+    /**
+   * Detects the domain locale from the hostname and the detected locale if
+   * provided.
+   *
+   * @param hostname The hostname to detect the domain locale from, this must be lowercased.
+   * @param detectedLocale The detected locale to use if the hostname does not match.
+   * @returns The domain locale if found, `undefined` otherwise.
+   */ detectDomainLocale(hostname, detectedLocale) {
+        if (!hostname || !this.lowerCaseDomains || !this.config.domains) return;
+        if (detectedLocale) detectedLocale = detectedLocale.toLowerCase();
+        for(let i = 0; i < this.lowerCaseDomains.length; i++){
+            var // Configuration validation ensures that the locale is not repeated in
+            // other domains locales.
+            _domainLocale_locales;
+            const domainLocale = this.lowerCaseDomains[i];
+            if (// We assume that the hostname is already lowercased.
+            domainLocale.hostname === hostname || ((_domainLocale_locales = domainLocale.locales) == null ? void 0 : _domainLocale_locales.some((locale)=>locale === detectedLocale))) {
+                return this.config.domains[i];
+            }
+        }
+        return;
+    }
+    /**
+   * Pulls the pre-computed locale and inference results from the query
+   * object.
+   *
+   * @param pathname the pathname that could contain a locale prefix
+   * @param query the query object
+   * @returns the locale analysis result
+   */ fromQuery(pathname, query) {
+        const detectedLocale = query.__nextLocale;
+        // If a locale was detected on the query, analyze the pathname to ensure
+        // that the locale matches.
+        if (detectedLocale) {
+            const analysis = this.analyze(pathname);
+            // If the analysis contained a locale we should validate it against the
+            // query and strip it from the pathname.
+            if (analysis.detectedLocale) {
+                if (analysis.detectedLocale !== detectedLocale) {
+                    throw new Error(`Invariant: The detected locale does not match the locale in the query. Expected to find '${detectedLocale}' in '${pathname}' but found '${analysis.detectedLocale}'}`);
+                }
+                pathname = analysis.pathname;
+            }
+        }
+        return {
+            pathname,
+            detectedLocale,
+            inferredFromDefault: query.__nextInferredLocaleFromDefault === "1"
+        };
+    }
+    /**
+   * Analyzes the pathname for a locale and returns the pathname without it.
+   *
+   * @param pathname The pathname that could contain a locale prefix.
+   * @param options The options to use when matching the locale.
+   * @returns The matched locale and the pathname without the locale prefix
+   *          (if any).
+   */ analyze(pathname, options = {}) {
+        let detectedLocale = options.defaultLocale;
+        // By default, we assume that the default locale was inferred if there was
+        // no detected locale.
+        let inferredFromDefault = typeof detectedLocale === "string";
+        // The first segment will be empty, because it has a leading `/`. If
+        // there is no further segment, there is no locale (or it's the default).
+        const segments = pathname.split("/", 2);
+        if (!segments[1]) return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+        // The second segment will contain the locale part if any.
+        const segment = segments[1].toLowerCase();
+        // See if the segment matches one of the locales. If it doesn't, there is
+        // no locale (or it's the default).
+        const index = this.lowerCaseLocales.indexOf(segment);
+        if (index < 0) return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+        // Return the case-sensitive locale.
+        detectedLocale = this.config.locales[index];
+        inferredFromDefault = false;
+        // Remove the `/${locale}` part of the pathname.
+        pathname = pathname.slice(detectedLocale.length + 1) || "/";
+        return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+    }
+}
+
+//# sourceMappingURL=i18n-provider.js.map

.next/standalone/node_modules/next/dist/server/future/helpers/interception-routes.js

@@ -0,0 +1,89 @@
+"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("../../../shared/lib/router/utils/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, marker, 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 new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`);
+    }
+    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 new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`);
+            }
+            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 new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`);
+            }
+            interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join("/");
+            break;
+        default:
+            throw new Error("Invariant: unexpected marker");
+    }
+    return {
+        interceptingRoute,
+        interceptedRoute
+    };
+}
+
+//# sourceMappingURL=interception-routes.js.map

.next/standalone/node_modules/next/dist/server/future/helpers/module-loader/node-module-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeModuleLoader", {
+    enumerable: true,
+    get: function() {
+        return NodeModuleLoader;
+    }
+});
+class NodeModuleLoader {
+    async load(id) {
+        if (process.env.NEXT_RUNTIME !== "edge") {
+            // Need to `await` to cover the case that route is marked ESM modules by ESM escalation.
+            return await (process.env.NEXT_MINIMAL ? __non_webpack_require__(id) : require(id));
+        }
+        throw new Error("NodeModuleLoader is not supported in edge runtime.");
+    }
+}
+
+//# sourceMappingURL=node-module-loader.js.map

.next/standalone/node_modules/next/dist/server/future/helpers/module-loader/route-module-loader.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RouteModuleLoader", {
+    enumerable: true,
+    get: function() {
+        return RouteModuleLoader;
+    }
+});
+const _nodemoduleloader = require("./node-module-loader");
+class RouteModuleLoader {
+    static async load(id, loader = new _nodemoduleloader.NodeModuleLoader()) {
+        const module = await loader.load(id);
+        if ("routeModule" in module) {
+            return module.routeModule;
+        }
+        throw new Error(`Module "${id}" does not export a routeModule.`);
+    }
+}
+
+//# sourceMappingURL=route-module-loader.js.map