fixed version control heatmap and activity

.next/standalone/node_modules/next/dist/server/future/route-matchers/app-page-route-matcher.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AppPageRouteMatcher", {
+    enumerable: true,
+    get: function() {
+        return AppPageRouteMatcher;
+    }
+});
+const _routematcher = require("./route-matcher");
+class AppPageRouteMatcher extends _routematcher.RouteMatcher {
+    get identity() {
+        return `${this.definition.pathname}?__nextPage=${this.definition.page}`;
+    }
+}
+
+//# sourceMappingURL=app-page-route-matcher.js.map

.next/standalone/node_modules/next/dist/server/future/route-matchers/app-route-route-matcher.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AppRouteRouteMatcher", {
+    enumerable: true,
+    get: function() {
+        return AppRouteRouteMatcher;
+    }
+});
+const _routematcher = require("./route-matcher");
+class AppRouteRouteMatcher extends _routematcher.RouteMatcher {
+}
+
+//# sourceMappingURL=app-route-route-matcher.js.map

.next/standalone/node_modules/next/dist/server/future/route-matchers/locale-route-matcher.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LocaleRouteMatcher", {
+    enumerable: true,
+    get: function() {
+        return LocaleRouteMatcher;
+    }
+});
+const _routematcher = require("./route-matcher");
+class LocaleRouteMatcher extends _routematcher.RouteMatcher {
+    /**
+   * Identity returns the identity part of the matcher. This is used to compare
+   * a unique matcher to another. This is also used when sorting dynamic routes,
+   * so it must contain the pathname part as well.
+   */ get identity() {
+        var _this_definition_i18n;
+        return `${this.definition.pathname}?__nextLocale=${(_this_definition_i18n = this.definition.i18n) == null ? void 0 : _this_definition_i18n.locale}`;
+    }
+    /**
+   * Match will attempt to match the given pathname against this route while
+   * also taking into account the locale information.
+   *
+   * @param pathname The pathname to match against.
+   * @param options The options to use when matching.
+   * @returns The match result, or `null` if there was no match.
+   */ match(pathname, options) {
+        var // If the options have a detected locale, then use that, otherwise use
+        // the route's locale.
+        _options_i18n, _this_definition_i18n;
+        // This is like the parent `match` method but instead this injects the
+        // additional `options` into the
+        const result = this.test(pathname, options);
+        if (!result) return null;
+        return {
+            definition: this.definition,
+            params: result.params,
+            detectedLocale: (options == null ? void 0 : (_options_i18n = options.i18n) == null ? void 0 : _options_i18n.detectedLocale) ?? ((_this_definition_i18n = this.definition.i18n) == null ? void 0 : _this_definition_i18n.locale)
+        };
+    }
+    /**
+   * Test will attempt to match the given pathname against this route while
+   * also taking into account the locale information.
+   *
+   * @param pathname The pathname to match against.
+   * @param options The options to use when matching.
+   * @returns The match result, or `null` if there was no match.
+   */ test(pathname, options) {
+        // If this route has locale information and we have detected a locale, then
+        // we need to compare the detected locale to the route's locale.
+        if (this.definition.i18n && (options == null ? void 0 : options.i18n)) {
+            // If we have detected a locale and it does not match this route's locale,
+            // then this isn't a match!
+            if (this.definition.i18n.locale && options.i18n.detectedLocale && this.definition.i18n.locale !== options.i18n.detectedLocale) {
+                return null;
+            }
+            // Perform regular matching against the locale stripped pathname now, the
+            // locale information matches!
+            return super.test(options.i18n.pathname);
+        }
+        // If we don't have locale information, then we can just perform regular
+        // matching.
+        return super.test(pathname);
+    }
+}
+
+//# sourceMappingURL=locale-route-matcher.js.map

.next/standalone/node_modules/next/dist/server/future/route-matchers/pages-api-route-matcher.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PagesAPILocaleRouteMatcher: null,
+    PagesAPIRouteMatcher: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PagesAPILocaleRouteMatcher: function() {
+        return PagesAPILocaleRouteMatcher;
+    },
+    PagesAPIRouteMatcher: function() {
+        return PagesAPIRouteMatcher;
+    }
+});
+const _localeroutematcher = require("./locale-route-matcher");
+const _routematcher = require("./route-matcher");
+class PagesAPIRouteMatcher extends _routematcher.RouteMatcher {
+}
+class PagesAPILocaleRouteMatcher extends _localeroutematcher.LocaleRouteMatcher {
+}
+
+//# sourceMappingURL=pages-api-route-matcher.js.map

.next/standalone/node_modules/next/dist/server/future/route-matchers/pages-route-matcher.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PagesLocaleRouteMatcher: null,
+    PagesRouteMatcher: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PagesLocaleRouteMatcher: function() {
+        return PagesLocaleRouteMatcher;
+    },
+    PagesRouteMatcher: function() {
+        return PagesRouteMatcher;
+    }
+});
+const _localeroutematcher = require("./locale-route-matcher");
+const _routematcher = require("./route-matcher");
+class PagesRouteMatcher extends _routematcher.RouteMatcher {
+}
+class PagesLocaleRouteMatcher extends _localeroutematcher.LocaleRouteMatcher {
+}
+
+//# sourceMappingURL=pages-route-matcher.js.map

.next/standalone/node_modules/next/dist/server/future/route-matchers/route-matcher.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RouteMatcher", {
+    enumerable: true,
+    get: function() {
+        return RouteMatcher;
+    }
+});
+const _utils = require("../../../shared/lib/router/utils");
+const _routematcher = require("../../../shared/lib/router/utils/route-matcher");
+const _routeregex = require("../../../shared/lib/router/utils/route-regex");
+class RouteMatcher {
+    constructor(definition){
+        this.definition = definition;
+        if ((0, _utils.isDynamicRoute)(definition.pathname)) {
+            this.dynamic = (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(definition.pathname));
+        }
+    }
+    /**
+   * Identity returns the identity part of the matcher. This is used to compare
+   * a unique matcher to another. This is also used when sorting dynamic routes,
+   * so it must contain the pathname part.
+   */ get identity() {
+        return this.definition.pathname;
+    }
+    get isDynamic() {
+        return this.dynamic !== undefined;
+    }
+    match(pathname) {
+        const result = this.test(pathname);
+        if (!result) return null;
+        return {
+            definition: this.definition,
+            params: result.params
+        };
+    }
+    test(pathname) {
+        if (this.dynamic) {
+            const params = this.dynamic(pathname);
+            if (!params) return null;
+            return {
+                params
+            };
+        }
+        if (pathname === this.definition.pathname) {
+            return {};
+        }
+        return null;
+    }
+}
+
+//# sourceMappingURL=route-matcher.js.map