@helpwave/hightide 0.1.24 → 0.1.26

package/dist/components/layout-and-navigation/BreadCrumb.js

@@ -1102,6 +1102,527 @@ var require_utils2 = __commonJS({
   }
 });
 
+// node_modules/next/dist/compiled/path-to-regexp/index.js
+var require_path_to_regexp = __commonJS({
+  "node_modules/next/dist/compiled/path-to-regexp/index.js"(exports2, module2) {
+    (() => {
+      "use strict";
+      if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = __dirname + "/";
+      var e = {};
+      (() => {
+        var n = e;
+        Object.defineProperty(n, "__esModule", { value: true });
+        n.pathToRegexp = n.tokensToRegexp = n.regexpToFunction = n.match = n.tokensToFunction = n.compile = n.parse = void 0;
+        function lexer(e2) {
+          var n2 = [];
+          var r = 0;
+          while (r < e2.length) {
+            var t = e2[r];
+            if (t === "*" || t === "+" || t === "?") {
+              n2.push({ type: "MODIFIER", index: r, value: e2[r++] });
+              continue;
+            }
+            if (t === "\\") {
+              n2.push({ type: "ESCAPED_CHAR", index: r++, value: e2[r++] });
+              continue;
+            }
+            if (t === "{") {
+              n2.push({ type: "OPEN", index: r, value: e2[r++] });
+              continue;
+            }
+            if (t === "}") {
+              n2.push({ type: "CLOSE", index: r, value: e2[r++] });
+              continue;
+            }
+            if (t === ":") {
+              var a = "";
+              var i = r + 1;
+              while (i < e2.length) {
+                var o = e2.charCodeAt(i);
+                if (o >= 48 && o <= 57 || o >= 65 && o <= 90 || o >= 97 && o <= 122 || o === 95) {
+                  a += e2[i++];
+                  continue;
+                }
+                break;
+              }
+              if (!a) throw new TypeError("Missing parameter name at ".concat(r));
+              n2.push({ type: "NAME", index: r, value: a });
+              r = i;
+              continue;
+            }
+            if (t === "(") {
+              var c = 1;
+              var f = "";
+              var i = r + 1;
+              if (e2[i] === "?") {
+                throw new TypeError('Pattern cannot start with "?" at '.concat(i));
+              }
+              while (i < e2.length) {
+                if (e2[i] === "\\") {
+                  f += e2[i++] + e2[i++];
+                  continue;
+                }
+                if (e2[i] === ")") {
+                  c--;
+                  if (c === 0) {
+                    i++;
+                    break;
+                  }
+                } else if (e2[i] === "(") {
+                  c++;
+                  if (e2[i + 1] !== "?") {
+                    throw new TypeError("Capturing groups are not allowed at ".concat(i));
+                  }
+                }
+                f += e2[i++];
+              }
+              if (c) throw new TypeError("Unbalanced pattern at ".concat(r));
+              if (!f) throw new TypeError("Missing pattern at ".concat(r));
+              n2.push({ type: "PATTERN", index: r, value: f });
+              r = i;
+              continue;
+            }
+            n2.push({ type: "CHAR", index: r, value: e2[r++] });
+          }
+          n2.push({ type: "END", index: r, value: "" });
+          return n2;
+        }
+        function parse(e2, n2) {
+          if (n2 === void 0) {
+            n2 = {};
+          }
+          var r = lexer(e2);
+          var t = n2.prefixes, a = t === void 0 ? "./" : t, i = n2.delimiter, o = i === void 0 ? "/#?" : i;
+          var c = [];
+          var f = 0;
+          var u = 0;
+          var p = "";
+          var tryConsume = function(e3) {
+            if (u < r.length && r[u].type === e3) return r[u++].value;
+          };
+          var mustConsume = function(e3) {
+            var n3 = tryConsume(e3);
+            if (n3 !== void 0) return n3;
+            var t2 = r[u], a2 = t2.type, i2 = t2.index;
+            throw new TypeError("Unexpected ".concat(a2, " at ").concat(i2, ", expected ").concat(e3));
+          };
+          var consumeText = function() {
+            var e3 = "";
+            var n3;
+            while (n3 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+              e3 += n3;
+            }
+            return e3;
+          };
+          var isSafe = function(e3) {
+            for (var n3 = 0, r2 = o; n3 < r2.length; n3++) {
+              var t2 = r2[n3];
+              if (e3.indexOf(t2) > -1) return true;
+            }
+            return false;
+          };
+          var safePattern = function(e3) {
+            var n3 = c[c.length - 1];
+            var r2 = e3 || (n3 && typeof n3 === "string" ? n3 : "");
+            if (n3 && !r2) {
+              throw new TypeError('Must have text between two parameters, missing text after "'.concat(n3.name, '"'));
+            }
+            if (!r2 || isSafe(r2)) return "[^".concat(escapeString(o), "]+?");
+            return "(?:(?!".concat(escapeString(r2), ")[^").concat(escapeString(o), "])+?");
+          };
+          while (u < r.length) {
+            var v = tryConsume("CHAR");
+            var s = tryConsume("NAME");
+            var d = tryConsume("PATTERN");
+            if (s || d) {
+              var g = v || "";
+              if (a.indexOf(g) === -1) {
+                p += g;
+                g = "";
+              }
+              if (p) {
+                c.push(p);
+                p = "";
+              }
+              c.push({ name: s || f++, prefix: g, suffix: "", pattern: d || safePattern(g), modifier: tryConsume("MODIFIER") || "" });
+              continue;
+            }
+            var x = v || tryConsume("ESCAPED_CHAR");
+            if (x) {
+              p += x;
+              continue;
+            }
+            if (p) {
+              c.push(p);
+              p = "";
+            }
+            var h = tryConsume("OPEN");
+            if (h) {
+              var g = consumeText();
+              var l = tryConsume("NAME") || "";
+              var m = tryConsume("PATTERN") || "";
+              var T = consumeText();
+              mustConsume("CLOSE");
+              c.push({ name: l || (m ? f++ : ""), pattern: l && !m ? safePattern(g) : m, prefix: g, suffix: T, modifier: tryConsume("MODIFIER") || "" });
+              continue;
+            }
+            mustConsume("END");
+          }
+          return c;
+        }
+        n.parse = parse;
+        function compile(e2, n2) {
+          return tokensToFunction(parse(e2, n2), n2);
+        }
+        n.compile = compile;
+        function tokensToFunction(e2, n2) {
+          if (n2 === void 0) {
+            n2 = {};
+          }
+          var r = flags(n2);
+          var t = n2.encode, a = t === void 0 ? function(e3) {
+            return e3;
+          } : t, i = n2.validate, o = i === void 0 ? true : i;
+          var c = e2.map(function(e3) {
+            if (typeof e3 === "object") {
+              return new RegExp("^(?:".concat(e3.pattern, ")$"), r);
+            }
+          });
+          return function(n3) {
+            var r2 = "";
+            for (var t2 = 0; t2 < e2.length; t2++) {
+              var i2 = e2[t2];
+              if (typeof i2 === "string") {
+                r2 += i2;
+                continue;
+              }
+              var f = n3 ? n3[i2.name] : void 0;
+              var u = i2.modifier === "?" || i2.modifier === "*";
+              var p = i2.modifier === "*" || i2.modifier === "+";
+              if (Array.isArray(f)) {
+                if (!p) {
+                  throw new TypeError('Expected "'.concat(i2.name, '" to not repeat, but got an array'));
+                }
+                if (f.length === 0) {
+                  if (u) continue;
+                  throw new TypeError('Expected "'.concat(i2.name, '" to not be empty'));
+                }
+                for (var v = 0; v < f.length; v++) {
+                  var s = a(f[v], i2);
+                  if (o && !c[t2].test(s)) {
+                    throw new TypeError('Expected all "'.concat(i2.name, '" to match "').concat(i2.pattern, '", but got "').concat(s, '"'));
+                  }
+                  r2 += i2.prefix + s + i2.suffix;
+                }
+                continue;
+              }
+              if (typeof f === "string" || typeof f === "number") {
+                var s = a(String(f), i2);
+                if (o && !c[t2].test(s)) {
+                  throw new TypeError('Expected "'.concat(i2.name, '" to match "').concat(i2.pattern, '", but got "').concat(s, '"'));
+                }
+                r2 += i2.prefix + s + i2.suffix;
+                continue;
+              }
+              if (u) continue;
+              var d = p ? "an array" : "a string";
+              throw new TypeError('Expected "'.concat(i2.name, '" to be ').concat(d));
+            }
+            return r2;
+          };
+        }
+        n.tokensToFunction = tokensToFunction;
+        function match(e2, n2) {
+          var r = [];
+          var t = pathToRegexp(e2, r, n2);
+          return regexpToFunction(t, r, n2);
+        }
+        n.match = match;
+        function regexpToFunction(e2, n2, r) {
+          if (r === void 0) {
+            r = {};
+          }
+          var t = r.decode, a = t === void 0 ? function(e3) {
+            return e3;
+          } : t;
+          return function(r2) {
+            var t2 = e2.exec(r2);
+            if (!t2) return false;
+            var i = t2[0], o = t2.index;
+            var c = /* @__PURE__ */ Object.create(null);
+            var _loop_1 = function(e3) {
+              if (t2[e3] === void 0) return "continue";
+              var r3 = n2[e3 - 1];
+              if (r3.modifier === "*" || r3.modifier === "+") {
+                c[r3.name] = t2[e3].split(r3.prefix + r3.suffix).map(function(e4) {
+                  return a(e4, r3);
+                });
+              } else {
+                c[r3.name] = a(t2[e3], r3);
+              }
+            };
+            for (var f = 1; f < t2.length; f++) {
+              _loop_1(f);
+            }
+            return { path: i, index: o, params: c };
+          };
+        }
+        n.regexpToFunction = regexpToFunction;
+        function escapeString(e2) {
+          return e2.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+        }
+        function flags(e2) {
+          return e2 && e2.sensitive ? "" : "i";
+        }
+        function regexpToRegexp(e2, n2) {
+          if (!n2) return e2;
+          var r = /\((?:\?<(.*?)>)?(?!\?)/g;
+          var t = 0;
+          var a = r.exec(e2.source);
+          while (a) {
+            n2.push({ name: a[1] || t++, prefix: "", suffix: "", modifier: "", pattern: "" });
+            a = r.exec(e2.source);
+          }
+          return e2;
+        }
+        function arrayToRegexp(e2, n2, r) {
+          var t = e2.map(function(e3) {
+            return pathToRegexp(e3, n2, r).source;
+          });
+          return new RegExp("(?:".concat(t.join("|"), ")"), flags(r));
+        }
+        function stringToRegexp(e2, n2, r) {
+          return tokensToRegexp(parse(e2, r), n2, r);
+        }
+        function tokensToRegexp(e2, n2, r) {
+          if (r === void 0) {
+            r = {};
+          }
+          var t = r.strict, a = t === void 0 ? false : t, i = r.start, o = i === void 0 ? true : i, c = r.end, f = c === void 0 ? true : c, u = r.encode, p = u === void 0 ? function(e3) {
+            return e3;
+          } : u, v = r.delimiter, s = v === void 0 ? "/#?" : v, d = r.endsWith, g = d === void 0 ? "" : d;
+          var x = "[".concat(escapeString(g), "]|$");
+          var h = "[".concat(escapeString(s), "]");
+          var l = o ? "^" : "";
+          for (var m = 0, T = e2; m < T.length; m++) {
+            var E = T[m];
+            if (typeof E === "string") {
+              l += escapeString(p(E));
+            } else {
+              var w = escapeString(p(E.prefix));
+              var y = escapeString(p(E.suffix));
+              if (E.pattern) {
+                if (n2) n2.push(E);
+                if (w || y) {
+                  if (E.modifier === "+" || E.modifier === "*") {
+                    var R = E.modifier === "*" ? "?" : "";
+                    l += "(?:".concat(w, "((?:").concat(E.pattern, ")(?:").concat(y).concat(w, "(?:").concat(E.pattern, "))*)").concat(y, ")").concat(R);
+                  } else {
+                    l += "(?:".concat(w, "(").concat(E.pattern, ")").concat(y, ")").concat(E.modifier);
+                  }
+                } else {
+                  if (E.modifier === "+" || E.modifier === "*") {
+                    throw new TypeError('Can not repeat "'.concat(E.name, '" without a prefix and suffix'));
+                  }
+                  l += "(".concat(E.pattern, ")").concat(E.modifier);
+                }
+              } else {
+                l += "(?:".concat(w).concat(y, ")").concat(E.modifier);
+              }
+            }
+          }
+          if (f) {
+            if (!a) l += "".concat(h, "?");
+            l += !r.endsWith ? "$" : "(?=".concat(x, ")");
+          } else {
+            var A = e2[e2.length - 1];
+            var _ = typeof A === "string" ? h.indexOf(A[A.length - 1]) > -1 : A === void 0;
+            if (!a) {
+              l += "(?:".concat(h, "(?=").concat(x, "))?");
+            }
+            if (!_) {
+              l += "(?=".concat(h, "|").concat(x, ")");
+            }
+          }
+          return new RegExp(l, flags(r));
+        }
+        n.tokensToRegexp = tokensToRegexp;
+        function pathToRegexp(e2, n2, r) {
+          if (e2 instanceof RegExp) return regexpToRegexp(e2, n2);
+          if (Array.isArray(e2)) return arrayToRegexp(e2, n2, r);
+          return stringToRegexp(e2, n2, r);
+        }
+        n.pathToRegexp = pathToRegexp;
+      })();
+      module2.exports = e;
+    })();
+  }
+});
+
+// node_modules/next/dist/lib/route-pattern-normalizer.js
+var require_route_pattern_normalizer = __commonJS({
+  "node_modules/next/dist/lib/route-pattern-normalizer.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      hasAdjacentParameterIssues: function() {
+        return hasAdjacentParameterIssues;
+      },
+      normalizeAdjacentParameters: function() {
+        return normalizeAdjacentParameters;
+      },
+      normalizeTokensForRegexp: function() {
+        return normalizeTokensForRegexp;
+      },
+      stripParameterSeparators: function() {
+        return stripParameterSeparators;
+      }
+    });
+    var PARAM_SEPARATOR = "_NEXTSEP_";
+    function hasAdjacentParameterIssues(route) {
+      if (typeof route !== "string") return false;
+      if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) {
+        return true;
+      }
+      if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) {
+        return true;
+      }
+      return false;
+    }
+    function normalizeAdjacentParameters(route) {
+      let normalized = route;
+      normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+      normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+      return normalized;
+    }
+    function normalizeTokensForRegexp(tokens) {
+      return tokens.map((token) => {
+        if (typeof token === "object" && token !== null && // Not all token objects have 'modifier' property (e.g., simple text tokens)
+        "modifier" in token && // Only repeating modifiers (* or +) cause the validation error
+        // Other modifiers like '?' (optional) are fine
+        (token.modifier === "*" || token.modifier === "+") && // Token objects can have different shapes depending on route pattern
+        "prefix" in token && "suffix" in token && // Both prefix and suffix must be empty strings
+        // This is what causes the validation error in path-to-regexp
+        token.prefix === "" && token.suffix === "") {
+          return {
+            ...token,
+            prefix: "/"
+          };
+        }
+        return token;
+      });
+    }
+    function stripParameterSeparators(params) {
+      const cleaned = {};
+      for (const [key, value] of Object.entries(params)) {
+        if (typeof value === "string") {
+          cleaned[key] = value.replace(new RegExp(`^${PARAM_SEPARATOR}`), "");
+        } else if (Array.isArray(value)) {
+          cleaned[key] = value.map((item) => typeof item === "string" ? item.replace(new RegExp(`^${PARAM_SEPARATOR}`), "") : item);
+        } else {
+          cleaned[key] = value;
+        }
+      }
+      return cleaned;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/route-match-utils.js
+var require_route_match_utils = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/route-match-utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      safeCompile: function() {
+        return safeCompile;
+      },
+      safePathToRegexp: function() {
+        return safePathToRegexp;
+      },
+      safeRegexpToFunction: function() {
+        return safeRegexpToFunction;
+      },
+      safeRouteMatcher: function() {
+        return safeRouteMatcher;
+      }
+    });
+    var _pathtoregexp = require_path_to_regexp();
+    var _routepatternnormalizer = require_route_pattern_normalizer();
+    function safePathToRegexp(route, keys, options) {
+      if (typeof route !== "string") {
+        return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
+      }
+      const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+      const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+      try {
+        return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
+      } catch (error) {
+        if (!needsNormalization) {
+          try {
+            const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+            return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
+          } catch (retryError) {
+            throw error;
+          }
+        }
+        throw error;
+      }
+    }
+    function safeCompile(route, options) {
+      const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+      const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+      try {
+        return (0, _pathtoregexp.compile)(routeToUse, options);
+      } catch (error) {
+        if (!needsNormalization) {
+          try {
+            const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+            return (0, _pathtoregexp.compile)(normalizedRoute, options);
+          } catch (retryError) {
+            throw error;
+          }
+        }
+        throw error;
+      }
+    }
+    function safeRegexpToFunction(regexp, keys) {
+      const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
+      return (pathname) => {
+        const result = originalMatcher(pathname);
+        if (!result) return false;
+        return {
+          ...result,
+          params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
+        };
+      };
+    }
+    function safeRouteMatcher(matcherFn) {
+      return (pathname) => {
+        const result = matcherFn(pathname);
+        if (!result) return false;
+        return (0, _routepatternnormalizer.stripParameterSeparators)(result);
+      };
+    }
+  }
+});
+
 // node_modules/next/dist/shared/lib/router/utils/route-matcher.js
 var require_route_matcher = __commonJS({
   "node_modules/next/dist/shared/lib/router/utils/route-matcher.js"(exports2) {
@@ -1116,9 +1637,10 @@ var require_route_matcher = __commonJS({
       }
     });
     var _utils = require_utils();
+    var _routematchutils = require_route_match_utils();
     function getRouteMatcher(param) {
       let { re, groups } = param;
-      return (pathname) => {
+      const rawMatcher = (pathname) => {
         const routeMatch = re.exec(pathname);
         if (!routeMatch) return false;
         const decode = (param2) => {
@@ -1145,6 +1667,7 @@ var require_route_matcher = __commonJS({
         }
         return params;
       };
+      return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
     }
   }
 });
@@ -1187,12 +1710,18 @@ var require_constants = __commonJS({
       GSSP_NO_RETURNED_VALUE: function() {
         return GSSP_NO_RETURNED_VALUE;
       },
+      HTML_CONTENT_TYPE_HEADER: function() {
+        return HTML_CONTENT_TYPE_HEADER;
+      },
       INFINITE_CACHE: function() {
         return INFINITE_CACHE;
       },
       INSTRUMENTATION_HOOK_FILENAME: function() {
         return INSTRUMENTATION_HOOK_FILENAME;
       },
+      JSON_CONTENT_TYPE_HEADER: function() {
+        return JSON_CONTENT_TYPE_HEADER;
+      },
       MATCHED_PATH_HEADER: function() {
         return MATCHED_PATH_HEADER;
       },
@@ -1274,6 +1803,9 @@ var require_constants = __commonJS({
       RSC_CACHE_WRAPPER_ALIAS: function() {
         return RSC_CACHE_WRAPPER_ALIAS;
       },
+      RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS: function() {
+        return RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS;
+      },
       RSC_MOD_REF_PROXY_ALIAS: function() {
         return RSC_MOD_REF_PROXY_ALIAS;
       },
@@ -1310,6 +1842,9 @@ var require_constants = __commonJS({
       STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR: function() {
         return STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR;
       },
+      TEXT_PLAIN_CONTENT_TYPE_HEADER: function() {
+        return TEXT_PLAIN_CONTENT_TYPE_HEADER;
+      },
       UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
         return UNSTABLE_REVALIDATE_RENAME_ERROR;
       },
@@ -1320,6 +1855,9 @@ var require_constants = __commonJS({
         return WEBPACK_RESOURCE_QUERIES;
       }
     });
+    var TEXT_PLAIN_CONTENT_TYPE_HEADER = "text/plain";
+    var HTML_CONTENT_TYPE_HEADER = "text/html; charset=utf-8";
+    var JSON_CONTENT_TYPE_HEADER = "application/json; charset=utf-8";
     var NEXT_QUERY_PARAM_PREFIX = "nxtP";
     var NEXT_INTERCEPTION_MARKER_PREFIX = "nxtI";
     var MATCHED_PATH_HEADER = "x-matched-path";
@@ -1354,6 +1892,7 @@ var require_constants = __commonJS({
     var RSC_ACTION_VALIDATE_ALIAS = "private-next-rsc-action-validate";
     var RSC_ACTION_PROXY_ALIAS = "private-next-rsc-server-reference";
     var RSC_CACHE_WRAPPER_ALIAS = "private-next-rsc-cache-wrapper";
+    var RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS = "private-next-rsc-track-dynamic-import";
     var RSC_ACTION_ENCRYPTION_ALIAS = "private-next-rsc-action-encryption";
     var RSC_ACTION_CLIENT_WRAPPER_ALIAS = "private-next-rsc-action-client-wrapper";
     var PUBLIC_DIR_MIDDLEWARE_CONFLICT = `You can not have a '_next' folder inside of your public folder. This conflicts with the internal '/_next' route. https://nextjs.org/docs/messages/public-next-folder-conflict`;
@@ -1508,9 +2047,9 @@ var require_escape_regexp = __commonJS({
   }
 });
 
-// node_modules/next/dist/shared/lib/router/utils/route-regex.js
-var require_route_regex = __commonJS({
-  "node_modules/next/dist/shared/lib/router/utils/route-regex.js"(exports2) {
+// node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js
+var require_get_dynamic_param = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", {
       value: true
@@ -1522,23 +2061,75 @@ var require_route_regex = __commonJS({
       });
     }
     _export(exports2, {
-      getNamedMiddlewareRegex: function() {
-        return getNamedMiddlewareRegex;
+      PARAMETER_PATTERN: function() {
+        return PARAMETER_PATTERN;
       },
-      getNamedRouteRegex: function() {
-        return getNamedRouteRegex;
+      getDynamicParam: function() {
+        return getDynamicParam;
       },
-      getRouteRegex: function() {
-        return getRouteRegex;
+      parseMatchedParameter: function() {
+        return parseMatchedParameter;
       },
       parseParameter: function() {
         return parseParameter;
       }
     });
-    var _constants = require_constants();
-    var _interceptionroutes = require_interception_routes();
-    var _escaperegexp = require_escape_regexp();
-    var _removetrailingslash = require_remove_trailing_slash();
+    function getDynamicParam(params, segmentKey, dynamicParamType, pagePath, fallbackRouteParams) {
+      let value = params[segmentKey];
+      if (fallbackRouteParams && fallbackRouteParams.has(segmentKey)) {
+        value = fallbackRouteParams.get(segmentKey);
+      } else if (Array.isArray(value)) {
+        value = value.map((i) => encodeURIComponent(i));
+      } else if (typeof value === "string") {
+        value = encodeURIComponent(value);
+      }
+      if (!value) {
+        const isCatchall = dynamicParamType === "c";
+        const isOptionalCatchall = dynamicParamType === "oc";
+        if (isCatchall || isOptionalCatchall) {
+          if (isOptionalCatchall) {
+            return {
+              param: segmentKey,
+              value: null,
+              type: dynamicParamType,
+              treeSegment: [
+                segmentKey,
+                "",
+                dynamicParamType
+              ]
+            };
+          }
+          value = pagePath.split("/").slice(1).flatMap((pathSegment) => {
+            const param = parseParameter(pathSegment);
+            var _params_param_key;
+            return (_params_param_key = params[param.key]) != null ? _params_param_key : param.key;
+          });
+          return {
+            param: segmentKey,
+            value,
+            type: dynamicParamType,
+            // This value always has to be a string.
+            treeSegment: [
+              segmentKey,
+              value.join("/"),
+              dynamicParamType
+            ]
+          };
+        }
+      }
+      return {
+        param: segmentKey,
+        // The value that is passed to user code.
+        value,
+        // The value that is rendered in the router tree.
+        treeSegment: [
+          segmentKey,
+          Array.isArray(value) ? value.join("/") : value,
+          dynamicParamType
+        ],
+        type: dynamicParamType
+      };
+    }
     var PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
     function parseParameter(param) {
       const match = param.match(PARAMETER_PATTERN);
@@ -1562,15 +2153,47 @@ var require_route_regex = __commonJS({
         optional
       };
     }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/route-regex.js
+var require_route_regex = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/route-regex.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      getNamedMiddlewareRegex: function() {
+        return getNamedMiddlewareRegex;
+      },
+      getNamedRouteRegex: function() {
+        return getNamedRouteRegex;
+      },
+      getRouteRegex: function() {
+        return getRouteRegex;
+      }
+    });
+    var _constants = require_constants();
+    var _interceptionroutes = require_interception_routes();
+    var _escaperegexp = require_escape_regexp();
+    var _removetrailingslash = require_remove_trailing_slash();
+    var _getdynamicparam = require_get_dynamic_param();
     function getParametrizedRoute(route, includeSuffix, includePrefix) {
       const groups = {};
       let groupIndex = 1;
       const segments = [];
       for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
         const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
-        const paramMatches = segment.match(PARAMETER_PATTERN);
+        const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
         if (markerMatch && paramMatches && paramMatches[2]) {
-          const { key, optional, repeat } = parseMatchedParameter(paramMatches[2]);
+          const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
           groups[key] = {
             pos: groupIndex++,
             repeat,
@@ -1578,7 +2201,7 @@ var require_route_regex = __commonJS({
           };
           segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(markerMatch) + "([^/]+?)");
         } else if (paramMatches && paramMatches[2]) {
-          const { key, repeat, optional } = parseMatchedParameter(paramMatches[2]);
+          const { key, repeat, optional } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
           groups[key] = {
             pos: groupIndex++,
             repeat,
@@ -1630,7 +2253,7 @@ var require_route_regex = __commonJS({
     }
     function getSafeKeyFromSegment(param) {
       let { interceptionMarker, getSafeRouteKey, segment, routeKeys, keyPrefix, backreferenceDuplicateKeys } = param;
-      const { key, optional, repeat } = parseMatchedParameter(segment);
+      const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(segment);
       let cleanedKey = key.replace(/\W/g, "");
       if (keyPrefix) {
         cleanedKey = "" + keyPrefix + cleanedKey;
@@ -1668,7 +2291,7 @@ var require_route_regex = __commonJS({
       const segments = [];
       for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
         const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m) => segment.startsWith(m));
-        const paramMatches = segment.match(PARAMETER_PATTERN);
+        const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
         if (hasInterceptionMarker && paramMatches && paramMatches[2]) {
           segments.push(getSafeKeyFromSegment({
             getSafeRouteKey,
@@ -1813,10 +2436,12 @@ var require_resolve_href = __commonJS({
     var _islocalurl = require_is_local_url();
     var _utils1 = require_utils2();
     var _interpolateas = require_interpolate_as();
+    var _routeregex = require_route_regex();
+    var _routematcher = require_route_matcher();
     function resolveHref(router, href, resolveAs) {
       let base;
       let urlAsString = typeof href === "string" ? href : (0, _formaturl.formatWithValidation)(href);
-      const urlProtoMatch = urlAsString.match(/^[a-zA-Z]{1,}:\/\//);
+      const urlProtoMatch = urlAsString.match(/^[a-z][a-z0-9+.-]*:\/\//i);
       const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
       const urlParts = urlAsStringNoProto.split("?", 1);
       if ((urlParts[0] || "").match(/(\/\/|\\)/)) {
@@ -1830,7 +2455,19 @@ var require_resolve_href = __commonJS({
         ] : urlAsString;
       }
       try {
-        base = new URL(urlAsString.startsWith("#") ? router.asPath : router.pathname, "http://n");
+        let baseBase = urlAsString.startsWith("#") ? router.asPath : router.pathname;
+        if (urlAsString.startsWith("?")) {
+          baseBase = router.asPath;
+          if ((0, _utils1.isDynamicRoute)(router.pathname)) {
+            baseBase = router.pathname;
+            const routeRegex = (0, _routeregex.getRouteRegex)(router.pathname);
+            const match = (0, _routematcher.getRouteMatcher)(routeRegex)(router.asPath);
+            if (!match) {
+              baseBase = router.asPath;
+            }
+          }
+        }
+        base = new URL(baseBase, "http://n");
       } catch (_) {
         base = new URL("/", "http://n");
       }
@@ -2622,7 +3259,7 @@ var require_link = __commonJS({
                 actual: valType
               });
             }
-          } else if (key === "replace" || key === "scroll" || key === "shallow" || key === "passHref" || key === "prefetch" || key === "legacyBehavior") {
+          } else if (key === "replace" || key === "scroll" || key === "shallow" || key === "passHref" || key === "legacyBehavior") {
             if (props[key] != null && valType !== "boolean") {
               throw createPropError({
                 key,
@@ -2630,6 +3267,14 @@ var require_link = __commonJS({
                 actual: valType
               });
             }
+          } else if (key === "prefetch") {
+            if (props[key] != null && valType !== "boolean" && props[key] !== "auto") {
+              throw createPropError({
+                key,
+                expected: '`boolean | "auto"`',
+                actual: valType
+              });
+            }
           } else {
             const _ = key;
           }