@i18n-micro/path-strategy 1.0.0

package/dist/base-strategy-DVqe8ehd.js

@@ -0,0 +1,790 @@
+const rt = /#/g, lt = /&/g, it = /\//g, ct = /=/g, $ = /\+/g, G = /%5e/gi, ht = /%60/gi, ut = /%7b/gi, ft = /%7c/gi, pt = /%7d/gi, dt = /%20/gi;
+function D(s) {
+  return encodeURI("" + s).replace(ft, "|");
+}
+function mt(s) {
+  return D(s).replace(ut, "{").replace(pt, "}").replace(G, "^");
+}
+function w(s) {
+  return D(typeof s == "string" ? s : JSON.stringify(s)).replace($, "%2B").replace(dt, "+").replace(rt, "%23").replace(lt, "%26").replace(ht, "`").replace(G, "^").replace(it, "%2F");
+}
+function _(s) {
+  return w(s).replace(ct, "%3D");
+}
+function F(s = "") {
+  try {
+    return decodeURIComponent("" + s);
+  } catch {
+    return "" + s;
+  }
+}
+function gt(s) {
+  return F(s.replace($, " "));
+}
+function Pt(s) {
+  return F(s.replace($, " "));
+}
+function yt(s = "") {
+  const t = /* @__PURE__ */ Object.create(null);
+  s[0] === "?" && (s = s.slice(1));
+  for (const e of s.split("&")) {
+    const o = e.match(/([^=]+)=?(.*)/) || [];
+    if (o.length < 2)
+      continue;
+    const a = gt(o[1]);
+    if (a === "__proto__" || a === "constructor")
+      continue;
+    const n = Pt(o[2] || "");
+    t[a] === void 0 ? t[a] = n : Array.isArray(t[a]) ? t[a].push(n) : t[a] = [t[a], n];
+  }
+  return t;
+}
+function Rt(s, t) {
+  return (typeof t == "number" || typeof t == "boolean") && (t = String(t)), t ? Array.isArray(t) ? t.map(
+    (e) => `${_(s)}=${w(e)}`
+  ).join("&") : `${_(s)}=${w(t)}` : _(s);
+}
+function Lt(s) {
+  return Object.keys(s).filter((t) => s[t] !== void 0).map((t) => Rt(t, s[t])).filter(Boolean).join("&");
+}
+const bt = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/, Nt = /^[\s\w\0+.-]{2,}:([/\\]{2})?/, xt = /^([/\\]\s*){2,}[^/\\]/, zt = /^\.?\//;
+function W(s, t = {}) {
+  return typeof t == "boolean" && (t = { acceptRelative: t }), t.strict ? bt.test(s) : Nt.test(s) || (t.acceptRelative ? xt.test(s) : !1);
+}
+function vt(s = "", t) {
+  return s.endsWith("/");
+}
+function v(s = "", t) {
+  return (vt(s) ? s.slice(0, -1) : s) || "/";
+}
+function Bt(s = "", t) {
+  return s.endsWith("/") ? s : s + "/";
+}
+function U(s = "") {
+  return s.startsWith("/");
+}
+function T(s = "") {
+  return (U(s) ? s.slice(1) : s) || "/";
+}
+function K(s = "") {
+  return U(s) ? s : "/" + s;
+}
+function M(s = "") {
+  return s.split("://").map((t) => t.replace(/\/{2,}/g, "/")).join("://");
+}
+function St(s, t) {
+  const e = q(s), o = { ...yt(e.search), ...t };
+  return e.search = Lt(o), X(e);
+}
+function At(s) {
+  return !s || s === "/";
+}
+function Ft(s) {
+  return s && s !== "/";
+}
+function j(s, ...t) {
+  let e = s || "";
+  for (const o of t.filter((a) => Ft(a)))
+    if (e) {
+      const a = o.replace(zt, "");
+      e = Bt(e) + a;
+    } else
+      e = o;
+  return e;
+}
+function $t(s, t) {
+  return F(v(s)) === F(v(t));
+}
+function Wt(s, t) {
+  if (!t || t === "#")
+    return s;
+  const e = q(s);
+  return e.hash = t === "" ? "" : "#" + mt(t), X(e);
+}
+const V = /* @__PURE__ */ Symbol.for("ufo:protocolRelative");
+function q(s = "", t) {
+  const e = s.match(
+    /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
+  );
+  if (e) {
+    const [, d, P = ""] = e;
+    return {
+      protocol: d.toLowerCase(),
+      pathname: P,
+      href: d + P,
+      auth: "",
+      host: "",
+      search: "",
+      hash: ""
+    };
+  }
+  if (!W(s, { acceptRelative: !0 }))
+    return E(s);
+  const [, o = "", a, n = ""] = s.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+  let [, r = "", l = ""] = n.match(/([^#/?]*)(.*)?/) || [];
+  o === "file:" && (l = l.replace(/\/(?=[A-Za-z]:)/, ""));
+  const { pathname: c, search: u, hash: m } = E(l);
+  return {
+    protocol: o.toLowerCase(),
+    auth: a ? a.slice(0, Math.max(0, a.length - 1)) : "",
+    host: r,
+    pathname: c,
+    search: u,
+    hash: m,
+    [V]: !o
+  };
+}
+function E(s = "") {
+  const [t = "", e = "", o = ""] = (s.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+  return {
+    pathname: t,
+    search: e,
+    hash: o
+  };
+}
+function X(s) {
+  const t = s.pathname || "", e = s.search ? (s.search.startsWith("?") ? "" : "?") + s.search : "", o = s.hash || "", a = s.auth ? s.auth + "@" : "", n = s.host || "";
+  return (s.protocol || s[V] ? (s.protocol || "") + "//" : "") + a + n + t + e + o;
+}
+const Et = /\/([^/]+)$/;
+function Ut(s = "", t) {
+  const { pathname: e } = q(s), o = e.match(Et);
+  return o ? o[1] : void 0;
+}
+function J(s) {
+  return (E(s.startsWith("/") ? s : `/${s}`).pathname || "").split("/").filter(Boolean);
+}
+const y = (s) => At(s ?? "") ? "/" : K(v(M(s))) || "/";
+function jt(s) {
+  const t = M(s || "/");
+  return v(t) || "/";
+}
+function g(...s) {
+  const t = s.filter((n) => typeof n == "string" && n !== "");
+  if (t.length === 0) return "/";
+  const [e, ...o] = t, a = j(e, ...o) || "/";
+  return W(a) ? a : K(a);
+}
+function Y(s) {
+  return s && E(s).pathname || "";
+}
+function I(s, t, e) {
+  let o = St(s, t ?? {});
+  if (e && e !== "#") {
+    const a = e.startsWith("#") ? e.slice(1) : e;
+    o = Wt(o, a);
+  }
+  return o;
+}
+function N(s) {
+  if (!s) return "";
+  let t = "";
+  for (let e = 0; e < s.length; e++)
+    t += s[e] === "-" ? "/" : s[e];
+  return t;
+}
+function Z(s) {
+  if (!s) return "";
+  const t = s.indexOf("-");
+  return t === -1 ? s : j(s.slice(0, t), s.slice(t + 1));
+}
+function tt(s) {
+  if (!s) return "";
+  const t = s.lastIndexOf("-");
+  return t === -1 ? s : j(s.slice(0, t), s.slice(t + 1));
+}
+function qt(s) {
+  const t = J(s);
+  return t.length > 1 ? t.slice(0, -1).join("-") : "";
+}
+function Qt(s) {
+  return Ut(s || "/") ?? "";
+}
+function C(s, t) {
+  const e = s.name?.toString();
+  if (!e) return null;
+  const o = t.localizedRouteNamePrefix || "localized-", a = e.startsWith(o) ? e.slice(o.length) : e, n = [...t.locales].sort((r, l) => l.code.length - r.code.length);
+  for (const r of n) {
+    const l = `-${r.code}`;
+    if (!a.endsWith(l)) continue;
+    const c = a.length - r.code.length - 1;
+    if (c >= 0 && a[c] === "-")
+      return a.slice(0, -l.length);
+  }
+  return a;
+}
+function kt(s, t, e = "localized-") {
+  return `${e}${s}-${t}`;
+}
+function H(s, t) {
+  if (s == null) return !1;
+  const e = String(s).trim();
+  if (e === "" || e === "index") return !0;
+  const o = t?.localizedRouteNamePrefix ?? "localized-", a = t?.localeCodes ?? [], n = `${o}index-`;
+  if (!e.startsWith(n)) return !1;
+  const r = e.slice(n.length);
+  return a.length === 0 ? r.length >= 2 : a.includes(r);
+}
+function et(s, t) {
+  const e = Y(s), o = y(e);
+  if (o === "/")
+    return { pathWithoutLocale: "/", localeFromPath: null };
+  if (!U(o))
+    return { pathWithoutLocale: o, localeFromPath: null };
+  const a = o.indexOf("/", 1), n = a === -1 ? o.slice(1) : o.slice(1, a);
+  if (n && t.includes(n)) {
+    const r = 1 + n.length, l = o.slice(r);
+    return {
+      pathWithoutLocale: y(l || "/"),
+      localeFromPath: n
+    };
+  }
+  return { pathWithoutLocale: o, localeFromPath: null };
+}
+function _t(s, t) {
+  const e = Y(s);
+  if (e === "/" || e === "" || !U(e)) return null;
+  const o = e.indexOf("/", 1), a = o === -1 ? e.slice(1) : e.slice(1, o);
+  return a && t.includes(a) ? a : null;
+}
+function wt(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+class Ct {
+  constructor(t) {
+    this.ctx = t;
+  }
+  /**
+   * Substitutes params into path template (:key, :key(), [...key]).
+   * Uses one combined regex per key to avoid creating multiple RegExp in a loop.
+   */
+  resolvePathWithParams(t, e = {}) {
+    let o = t;
+    for (const a in e) {
+      const n = e[a];
+      if (n == null || n === "") continue;
+      const r = Array.isArray(n) ? n.join("/") : String(n), l = wt(a), c = new RegExp(
+        `:${l}\\(\\)|:${l}(?![\\w])|\\[\\.\\.\\.${l}\\]`,
+        "g"
+      );
+      o = o.replace(c, r);
+    }
+    return o;
+  }
+  /**
+   * Analyzes route: path without locale and base name (normalizer + route-name).
+   */
+  analyzeRoute(t) {
+    const e = this.ctx.locales.map((n) => n.code), { pathWithoutLocale: o } = et(t.path || "/", e);
+    let a = null;
+    return t.name && (a = C(t, {
+      locales: this.ctx.locales,
+      localizedRouteNamePrefix: this.ctx.localizedRouteNamePrefix || "localized-"
+    })), { pathWithoutLocale: o, baseRouteName: a };
+  }
+  /** Public access to route analysis (for strategies). */
+  getPathWithoutLocaleAndBaseName(t) {
+    return this.analyzeRoute(t);
+  }
+  /**
+   * Lookup keys for config (same order for resolveCustomPath, getPathForUnlocalizedRoute, getAllowedLocalesForRoute).
+   */
+  getLookupKeys(t, e) {
+    const o = [];
+    o.push(t);
+    const a = T(t);
+    if (a !== t && o.push(a), (t === "/" || a === "") && o.push(""), e) {
+      o.push(`/${e}`), o.push(e);
+      const n = N(e);
+      n && n !== e && o.push(n);
+      const r = Z(e);
+      r && o.push(r);
+      const l = tt(e);
+      l && o.push(l);
+    }
+    return o;
+  }
+  /**
+   * Resolves custom path for targetLocale from globalLocaleRoutes.
+   */
+  resolveCustomPath(t, e) {
+    const o = this.ctx.globalLocaleRoutes;
+    if (!o || Object.keys(o).length === 0) return null;
+    const { pathWithoutLocale: a, baseRouteName: n } = this.analyzeRoute(t), r = this.getLookupKeys(a, n);
+    for (const l of r) {
+      const c = o[l];
+      if (c && typeof c == "object" && !Array.isArray(c)) {
+        const u = c[e];
+        if (typeof u == "string")
+          return this.resolvePathWithParams(u, t.params ?? {});
+      }
+    }
+    return null;
+  }
+  /**
+   * Unlocalized route (globalLocaleRoutes[key] === false) — returns path without locale.
+   */
+  getPathForUnlocalizedRoute(t) {
+    const e = this.ctx.globalLocaleRoutes;
+    if (!e) return null;
+    const { pathWithoutLocale: o, baseRouteName: a } = this.analyzeRoute(t), n = this.getLookupKeys(o, a);
+    for (const r of n)
+      if (e[r] === !1) {
+        if (a && (r === a || r === `/${a}`)) {
+          const l = N(a);
+          return l ? g("/", l) : `/${a}`;
+        }
+        return o;
+      }
+    return null;
+  }
+  /**
+   * Unlocalized by name (when no route object available).
+   */
+  getPathForUnlocalizedRouteByName(t) {
+    const e = this.ctx.globalLocaleRoutes;
+    if (!e) return null;
+    const o = [
+      t,
+      `/${t}`,
+      T(t)
+    ];
+    for (const a of o)
+      if (e[a] === !1) {
+        const n = N(a.startsWith("/") ? a.slice(1) : a);
+        return n ? g("/", n) : a.startsWith("/") ? a : `/${a}`;
+      }
+    return null;
+  }
+  /**
+   * Allowed locales for route (routeLocales).
+   */
+  getAllowedLocalesForRoute(t) {
+    const e = this.ctx.routeLocales;
+    if (!e || Object.keys(e).length === 0)
+      return this.ctx.locales.map((r) => r.code);
+    const { pathWithoutLocale: o, baseRouteName: a } = this.analyzeRoute(t);
+    let n = this.getLookupKeys(o, a);
+    a && this.ctx.routesLocaleLinks?.[a] && (n = [this.ctx.routesLocaleLinks[a], ...n]);
+    for (const r of n) {
+      const l = e[r];
+      if (Array.isArray(l) && l.length > 0)
+        return l.filter((c) => this.ctx.locales.some((u) => u.code === c));
+    }
+    return this.ctx.locales.map((r) => r.code);
+  }
+  /**
+   * Parent path for nested route (parent key -> targetLocale path).
+   */
+  getParentPathForNested(t, e) {
+    if (t.length <= 1) return "/";
+    const o = t.length > 1 ? t.slice(0, -1).join("-") : "", a = this.ctx.globalLocaleRoutes;
+    if (o && a?.[o] && typeof a[o] == "object") {
+      const n = a[o];
+      if (n[e])
+        return y(n[e]);
+    }
+    return g("/", ...t.slice(0, -1));
+  }
+}
+class Ot {
+  constructor(t) {
+    this.ctx = t, this.resolver = new Ct(t);
+  }
+  setRouter(t) {
+    this.ctx.router = t;
+  }
+  getDefaultLocale() {
+    return this.ctx.defaultLocale;
+  }
+  getLocales() {
+    return this.ctx.locales;
+  }
+  getStrategy() {
+    return this.ctx.strategy;
+  }
+  getLocalizedRouteNamePrefix() {
+    return this.ctx.localizedRouteNamePrefix || "localized-";
+  }
+  getGlobalLocaleRoutes() {
+    return this.ctx.globalLocaleRoutes;
+  }
+  getRouteLocales() {
+    return this.ctx.routeLocales;
+  }
+  getRoutesLocaleLinks() {
+    return this.ctx.routesLocaleLinks;
+  }
+  getNoPrefixRedirect() {
+    return this.ctx.noPrefixRedirect;
+  }
+  /** Strips localization prefix/suffix and returns the "base" route name for one locale. */
+  getBaseRouteName(t, e) {
+    return C(t, {
+      locales: [{ code: e }],
+      localizedRouteNamePrefix: this.getLocalizedRouteNamePrefix()
+    });
+  }
+  /** Returns the base route name (without localized prefix/suffix) by trying all locales. */
+  getRouteBaseName(t) {
+    return C(t, {
+      locales: this.ctx.locales,
+      localizedRouteNamePrefix: this.getLocalizedRouteNamePrefix()
+    });
+  }
+  /** Resolves target path for a locale, checking globalLocaleRoutes first. */
+  resolvePathForLocale(t, e) {
+    const o = {
+      path: t,
+      name: null,
+      fullPath: t,
+      params: {}
+    }, a = this.resolver.resolveCustomPath(o, e);
+    return y(a || t);
+  }
+  buildLocalizedName(t, e) {
+    return kt(t, e, this.getLocalizedRouteNamePrefix());
+  }
+  getLocaleObject(t) {
+    return this.ctx.locales.find((e) => e.code === t);
+  }
+  applyBaseUrl(t, e) {
+    if (typeof e == "string") {
+      if (W(e)) return e;
+    } else if (e.path && W(e.path))
+      return e;
+    const o = this.getLocaleObject(t);
+    if (!o?.baseUrl)
+      return e;
+    const a = v(o.baseUrl);
+    if (typeof e == "string") {
+      const l = y(e.startsWith("/") ? e : `/${e}`);
+      return g(a, l);
+    }
+    const n = y(e.path || ""), r = g(a, n);
+    return {
+      ...e,
+      path: r,
+      fullPath: r
+    };
+  }
+  /**
+   * Merges target route (strategy result) with query and hash from source route.
+   * Returns normalized RouteLike object.
+   */
+  preserveQueryAndHash(t, e) {
+    if (!e || !e.query && !e.hash)
+      return t;
+    const o = typeof t == "string" ? { path: t } : { ...t };
+    e.query && (o.query = { ...e.query, ...o.query }), !o.hash && e.hash && (o.hash = e.hash);
+    const a = o.path ?? "";
+    return o.fullPath = I(a, o.query, o.hash), o;
+  }
+  resolvePathWithParams(t, e = {}) {
+    return this.resolver.resolvePathWithParams(t, e);
+  }
+  getPathWithoutLocaleAndBaseName(t) {
+    return this.resolver.getPathWithoutLocaleAndBaseName(t);
+  }
+  /** Look up custom path segment for targetLocale in globalLocaleRoutes. */
+  getCustomPathSegment(t, e) {
+    return this.resolver.resolveCustomPath(t, e);
+  }
+  getAllowedLocalesForRoute(t) {
+    return this.resolver.getAllowedLocalesForRoute(t);
+  }
+  getCanonicalPath(t, e) {
+    return null;
+  }
+  getPathForUnlocalizedRouteByName(t) {
+    return this.resolver.getPathForUnlocalizedRouteByName(t);
+  }
+  /**
+   * Try to resolve route by localized name. Returns RouteLike with query/hash from sourceRoute to preserve them.
+   */
+  tryResolveByLocalizedName(t, e, o) {
+    const a = `${this.getLocalizedRouteNamePrefix()}${t}-${e}`, n = this.ctx.router.hasRoute(a);
+    if (this.debugLog("tryResolveByLocalizedName", { routeName: t, targetLocale: e, localizedName: a, hasRoute: n }), !n) return null;
+    const r = this.ctx.router.resolve({
+      name: a,
+      params: o?.params,
+      query: o?.query,
+      hash: o?.hash
+    });
+    return this.debugLog("tryResolveByLocalizedName resolved", { localizedName: a, path: r?.path, fullPath: r?.fullPath }), r?.path ? {
+      name: a,
+      path: r.path,
+      fullPath: r.fullPath,
+      params: r.params,
+      query: r.query ?? o?.query,
+      hash: r.hash ?? o?.hash
+    } : null;
+  }
+  /**
+   * Try to resolve route by localized name with params. Returns RouteLike to preserve query/hash.
+   */
+  tryResolveByLocalizedNameWithParams(t, e, o, a) {
+    const n = `${this.getLocalizedRouteNamePrefix()}${t}-${e}`, r = this.ctx.router.hasRoute(n);
+    if (this.debugLog("tryResolveByLocalizedNameWithParams", { routeName: t, targetLocale: e, params: o, localizedName: n, hasRoute: r }), !r) return null;
+    const l = this.ctx.router.resolve({
+      name: n,
+      params: o,
+      query: a?.query,
+      hash: a?.hash
+    });
+    return this.debugLog("tryResolveByLocalizedNameWithParams resolved", { path: l?.path, fullPath: l?.fullPath }), !l?.path || l.path === "/" ? null : {
+      name: n,
+      path: l.path,
+      fullPath: l.fullPath,
+      params: l.params,
+      query: l.query ?? a?.query,
+      hash: l.hash ?? a?.hash
+    };
+  }
+  getPathForUnlocalizedRoute(t) {
+    return this.resolver.getPathForUnlocalizedRoute(t);
+  }
+  /**
+   * Builds localized path from baseName + params when router does not have the route.
+   * Tries two conventions:
+   * 1) Hyphen form (Nuxt test-[id].vue → /test-:id): when single param key equals last baseName segment (e.g. test-id + id → test-:id).
+   * 2) Slash form (kebab→slash): path segments from baseName, last N replaced by :paramKey (e.g. test-id → /test/:id).
+   */
+  buildPathFromBaseNameAndParams(t, e, o) {
+    const a = Object.keys(e).filter((m) => e[m] !== void 0 && e[m] !== null && e[m] !== "");
+    if (a.length === 0) return null;
+    let n;
+    const r = a[0];
+    if (a.length === 1 && r !== void 0 && t.endsWith("-" + r))
+      n = g("/", t.slice(0, t.length - r.length - 1) + "-:" + r);
+    else {
+      const m = N(t), d = m ? m.split("/").filter(Boolean) : [t], P = Math.min(a.length, d.length), R = d.slice(0, d.length - P).concat(a.slice(0, P).map((B) => `:${B}`));
+      n = g("/", ...R);
+    }
+    const l = this.resolvePathWithParams(n, e), c = this.buildLocalizedPath(l, o, !1), u = this.applyBaseUrl(o, c);
+    return typeof u == "string" ? u : u.path ?? c;
+  }
+  getPathWithoutLocale(t) {
+    return et(t, this.ctx.locales.map((e) => e.code));
+  }
+  getLocaleFromPath(t) {
+    return _t(t, this.ctx.locales.map((e) => e.code));
+  }
+  /**
+   * Builds SEO attributes (canonical + hreflangs) from current route.
+   * Respects routeLocales: only allowed locales for this route get an hreflang entry.
+   * routesLocaleLinks is used when resolving the route key for routeLocales lookup.
+   */
+  getSeoAttributes(t) {
+    const e = this.resolveLocaleFromPath(t.path) ?? this.ctx.defaultLocale, o = this.getCanonicalPath(t, e) ?? t.path, a = this.buildFullUrl(e, o), n = this.getAllowedLocalesForRoute(t), l = this.ctx.locales.filter((c) => n.includes(c.code)).map((c) => {
+      const u = this.localeRoute(c.code, t, t), d = (u.path ?? u.fullPath ?? "") || "/";
+      return {
+        rel: "alternate",
+        hreflang: c.code,
+        href: this.buildFullUrl(c.code, d)
+      };
+    });
+    return { canonical: a, hreflangs: l };
+  }
+  /**
+   * Builds full URL (path + optional baseUrl for locale).
+   */
+  buildFullUrl(t, e) {
+    const o = this.applyBaseUrl(t, e);
+    return typeof o == "string" ? o : o.path ?? e;
+  }
+  /** When router knows neither targetName nor baseName — what to return (strategy may override). */
+  getSwitchLocaleFallbackWhenNoRoute(t, e) {
+    return { ...t, name: e };
+  }
+  /**
+   * Default: baseName → buildLocalizedRouteName → hasRoute → applyBaseUrl; fallback to baseName.
+   */
+  switchLocaleRoute(t, e, o, a) {
+    const n = this.getBaseRouteName(o, t);
+    if (!n) return o;
+    let r = this.buildLocalizedRouteName(n, e);
+    if (!this.ctx.router.hasRoute(r))
+      if (this.ctx.router.hasRoute(n))
+        r = n;
+      else
+        return this.getSwitchLocaleFallbackWhenNoRoute(o, r);
+    const l = a.i18nRouteParams?.[e] || {}, c = { ...o.params || {}, ...l };
+    delete c.locale;
+    const u = {
+      name: r,
+      params: c,
+      query: o.query,
+      hash: o.hash
+    };
+    return this.applyBaseUrl(e, u);
+  }
+  /**
+   * Template Method: BaseStrategy knows "how" (normalize → delegate to strategy).
+   * Always returns RouteLike with path and fullPath (never a string).
+   */
+  localeRoute(t, e, o) {
+    const a = this.normalizeRouteInput(e, o), n = this.resolveLocaleRoute(t, a, o);
+    this.debugLog("localeRoute raw", { rawPath: typeof n == "string" ? n : n.path, rawFullPath: typeof n == "string" ? n : n.fullPath });
+    const r = this.ensureRouteLike(n, a.kind === "route" ? a.sourceRoute : void 0);
+    return this.debugLog("localeRoute after ensureRouteLike", { path: r.path, fullPath: r.fullPath }), r;
+  }
+  /** Normalizes resolveLocaleRoute result into RouteLike (path and fullPath always set). */
+  ensureRouteLike(t, e) {
+    if (typeof t == "string") {
+      const n = t, r = e?.query || e?.hash ? I(n, e?.query, e?.hash) : n;
+      return {
+        path: n,
+        fullPath: r,
+        ...e?.query && { query: e.query },
+        ...e?.hash && { hash: e.hash }
+      };
+    }
+    let o = t.fullPath ?? t.path ?? "", a = t.path ?? o.split("?")[0]?.split("#")[0] ?? o;
+    if (!a && !o) {
+      const n = t.name?.toString() ?? e?.name?.toString() ?? "";
+      H(n, {
+        localizedRouteNamePrefix: this.getLocalizedRouteNamePrefix(),
+        localeCodes: this.ctx.locales.map((r) => r.code)
+      }) && (a = "/", o = "/");
+    }
+    return { ...t, path: a, fullPath: o };
+  }
+  /**
+   * Normalizes localeRoute input into a single structure (path string or route with resolved).
+   */
+  normalizeRouteInput(t, e) {
+    if (typeof t == "string")
+      return { kind: "path", path: t };
+    const o = t, a = o.name?.toString() ?? null;
+    let n;
+    try {
+      n = this.ctx.router.resolve(t), this.debugLog("normalizeRouteInput router.resolve ok", { inputName: a, resolvedPath: n.path, resolvedName: n.name });
+    } catch {
+      n = {
+        name: a,
+        path: o.path ?? "/",
+        fullPath: o.fullPath ?? o.path ?? "/",
+        params: o.params ?? {},
+        query: o.query ?? {},
+        hash: o.hash ?? ""
+      }, this.debugLog("normalizeRouteInput router.resolve catch fallback", { inputName: a, resolvedPath: n.path });
+    }
+    return { kind: "route", inputName: a, sourceRoute: o, resolved: n };
+  }
+  /** Logging when ctx.debug (for localeRoute debugging). Disabled by default. */
+  debugLog(...t) {
+  }
+  /**
+   * Default resolution: uses buildLocalizedPath and buildLocalizedRouteName.
+   * Strategies with different logic (e.g. prefix-except-default) override this method.
+   */
+  resolveLocaleRoute(t, e, o) {
+    if (e.kind === "path") {
+      const i = this.resolvePathForLocale(e.path, t), h = this.buildLocalizedPath(i, t, !1), f = this.applyBaseUrl(t, h);
+      return this.debugLog("branch=path", { targetLocale: t, path: e.path, finalPath: h, out: typeof f == "string" ? f : f.path }), f;
+    }
+    const { inputName: a, sourceRoute: n, resolved: r } = e, l = n.params && Object.keys(n.params ?? {}).length > 0, c = this.getRouteBaseName(r) ?? a ?? r.name?.toString() ?? null, u = r.name?.toString();
+    if (this.debugLog("input", { targetLocale: t, inputName: a, resolvedPath: r.path, resolvedName: r.name, params: n.params, hasParams: l, baseName: c }), a) {
+      const i = this.getPathForUnlocalizedRouteByName(a);
+      if (i !== null)
+        return this.debugLog("branch=unlocalizedByName", { inputName: a, unlocalizedByName: i }), this.preserveQueryAndHash(i, n);
+    }
+    if (a && l) {
+      const i = this.tryResolveByLocalizedNameWithParams(
+        a,
+        t,
+        n.params ?? {},
+        n
+      );
+      if (i !== null)
+        return this.debugLog("branch=routeWithParams", { inputName: a, path: i.path, fullPath: i.fullPath }), this.preserveQueryAndHash(this.applyBaseUrl(t, i), n);
+    }
+    if (a && !l) {
+      let i = this.tryResolveByLocalizedName(a, t, n);
+      const h = this.getLocalizedRouteNamePrefix();
+      if (i === null && c != null && c !== a && a.startsWith(h) && (i = this.tryResolveByLocalizedName(c, t, n)), i !== null)
+        return this.debugLog("branch=routeByLocalizedName", { inputName: a, path: i.path, fullPath: i.fullPath }), this.preserveQueryAndHash(this.applyBaseUrl(t, i), n);
+    }
+    const m = this.getPathForUnlocalizedRoute(r);
+    if (m !== null) {
+      const i = this.buildLocalizedPath(m, t, !1);
+      return this.debugLog("branch=unlocalizedPath", { unlocalizedPath: m, path: i }), this.preserveQueryAndHash(this.applyBaseUrl(t, i), n);
+    }
+    const d = this.getCustomPathSegment(r, t);
+    if (d !== null) {
+      const i = r.name?.toString() ?? a ?? "", h = i ? Z(i) : "", f = i ? tt(i) : "", p = this.ctx.globalLocaleRoutes, x = h.includes("/") && p?.[h], b = f.includes("/") && p?.[f], st = x || b, at = b ? f : h;
+      let A;
+      if (st) {
+        const k = J(at), z = k.length > 1 ? k.slice(0, -1).join("-") : "", O = z && p?.[z] && typeof p[z] == "object" && !Array.isArray(p[z]) ? p[z] : null, ot = O?.[t] ? y(O[t]) : g("/", ...k.slice(0, -1)), nt = d.startsWith("/") ? d.slice(1) : d;
+        A = g(ot, nt);
+      } else
+        A = y(d);
+      const Q = this.buildLocalizedPath(A, t, !0);
+      return this.debugLog("branch=customSegment", { customSegment: d, pathWithoutLocale: A, finalPath: Q }), this.preserveQueryAndHash(this.applyBaseUrl(t, Q), n);
+    }
+    const P = c ?? a;
+    if (this.debugLog("before effectiveBaseName check", { baseName: c, inputName: a, effectiveBaseName: P, resolvedName: r.name?.toString() }), !P)
+      return this.debugLog("branch=noBaseName", { return: "src" }), n;
+    if (!l && r.path && r.path !== "/" && r.name) {
+      const { pathWithoutLocale: i, baseRouteName: h } = this.getPathWithoutLocaleAndBaseName(r);
+      if (i && i !== "/") {
+        const f = h && i === h ? g("/", N(h)) : i, p = this.buildLocalizedPath(f, t, !1);
+        return this.debugLog("branch=pathFromResolved", { pathWithoutLocale: i, baseRouteName: h, pathToUse: f, finalPath: p }), this.preserveQueryAndHash(this.applyBaseUrl(t, p), n);
+      }
+    }
+    const R = u === a ? P : a ?? P;
+    this.debugLog("fallback build", { resolvedNameStr: u, inputName: a, baseNameForPath: R, targetLocale: t, hasParams: l });
+    const B = this.buildLocalizedRouteName(R, t), L = {
+      ...n,
+      name: B,
+      params: { ...n.params }
+    };
+    if (l) {
+      let i = null;
+      try {
+        const h = this.ctx.router.resolve({ name: R, params: n.params });
+        if (h?.path) {
+          const f = h.path === "/" ? "/" : (() => {
+            const { pathWithoutLocale: b } = this.getPathWithoutLocale(h.path);
+            return b && b !== "/" ? b : h.path;
+          })(), p = this.buildLocalizedPath(f, t, !1), x = this.applyBaseUrl(t, p);
+          i = typeof x == "string" ? x : x.path ?? p;
+        }
+      } catch {
+        i = this.buildPathFromBaseNameAndParams(R, n.params ?? {}, t);
+      }
+      i && (L.path = i, L.fullPath = i);
+    } else {
+      const i = H(R) ? "/" : g("/", N(R)), h = this.buildLocalizedPath(i, t, !1), f = this.applyBaseUrl(t, h), p = typeof f == "string" ? f : f.path ?? h;
+      this.debugLog("fallback !hasParams", { pathWithoutLocale: i, finalPath: h, pathStr: p }), L.path = p, L.fullPath = p;
+    }
+    const S = this.preserveQueryAndHash(this.applyBaseUrl(t, L), n);
+    return this.debugLog("branch=fallbackNewRoute return", { baseName: c, targetName: B, hasParams: l, newRoutePath: L.path, outPath: typeof S == "string" ? S : S.path }), S;
+  }
+}
+export {
+  Ot as B,
+  Ct as R,
+  jt as a,
+  tt as b,
+  M as c,
+  H as d,
+  Z as e,
+  J as f,
+  Y as g,
+  K as h,
+  $t as i,
+  g as j,
+  I as k,
+  Qt as l,
+  kt as m,
+  y as n,
+  _t as o,
+  qt as p,
+  et as q,
+  C as r,
+  N as t,
+  T as w
+};
+//# sourceMappingURL=base-strategy-DVqe8ehd.js.map