@esmx/router 3.0.0-rc.24 → 3.0.0-rc.26

package/dist/router-link.mjs

@@ -18,9 +18,13 @@ function getEventTypeList(eventType) {
   return validEvents.length ? validEvents : ["click"];
 }
 function guardEvent(e) {
-  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return false;
-  if (e.defaultPrevented) return false;
-  if (e.button !== void 0 && e.button !== 0) return false;
+  var _a, _b, _c;
+  if (!e) return;
+  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return;
+  if (e.defaultPrevented) return;
+  if (e.button !== void 0 && e.button !== 0) return;
+  const target = (_c = (_b = (_a = e.currentTarget) == null ? void 0 : _a.getAttribute) == null ? void 0 : _b.call(_a, "target")) != null ? _c : "";
+  if (/\b_blank\b/i.test(target)) return;
   if (e.preventDefault) e.preventDefault();
   return true;
 }
@@ -50,9 +54,9 @@ async function executeNavigation(router, props, linkType) {
 }
 function createNavigateFunction(router, props, navigationType) {
   return async (e) => {
-    if (e && !guardEvent(e)) {
-      return;
-    }
+    var _a;
+    const eventHandler = (_a = props.eventHandler) != null ? _a : guardEvent;
+    if (!eventHandler(e)) return;
     await executeNavigation(router, props, navigationType);
   };
 }
@@ -88,7 +92,8 @@ function createEventHandlersGenerator(navigate, eventTypes) {
   return (nameTransform) => {
     const handlers = {};
     eventTypes.forEach((eventType) => {
-      const eventName = nameTransform ? nameTransform(eventType) : eventType.toLowerCase();
+      var _a;
+      const eventName = (_a = nameTransform == null ? void 0 : nameTransform(eventType)) != null ? _a : eventType.toLowerCase();
       handlers[eventName] = navigate;
     });
     return handlers;

package/dist/router-restart-app.dom.test.mjs

@@ -246,7 +246,7 @@ describe("Router.restartApp Focused Tests", () => {
     it("should correctly execute beforeEach guards", async () => {
       const unregister = router.beforeEach(async (to, from) => {
         guardExecutionLog.push(
-          `beforeEach-${to.path}-from-${(from == null ? void 0 : from.path) || "null"}`
+          "beforeEach-".concat(to.path, "-from-").concat((from == null ? void 0 : from.path) || "null")
         );
       });
       await router.restartApp("/about");
@@ -256,7 +256,7 @@ describe("Router.restartApp Focused Tests", () => {
     it("should correctly execute afterEach guards", async () => {
       const unregister = router.afterEach((to, from) => {
         guardExecutionLog.push(
-          `afterEach-${to.path}-from-${(from == null ? void 0 : from.path) || "null"}`
+          "afterEach-".concat(to.path, "-from-").concat((from == null ? void 0 : from.path) || "null")
         );
       });
       await router.restartApp("/about");
@@ -504,10 +504,10 @@ describe("Router.restartApp Focused Tests", () => {
     });
     it("should correctly execute complete route lifecycle", async () => {
       const unregisterBefore = lifecycleRouter.beforeEach((to, from) => {
-        lifecycleLog.push(`global-beforeEach-${to.path}`);
+        lifecycleLog.push("global-beforeEach-".concat(to.path));
       });
       const unregisterAfter = lifecycleRouter.afterEach((to, from) => {
-        lifecycleLog.push(`global-afterEach-${to.path}`);
+        lifecycleLog.push("global-afterEach-".concat(to.path));
       });
       await lifecycleRouter.restartApp("/lifecycle");
       expect(lifecycleLog).toEqual([
@@ -588,7 +588,7 @@ describe("Router.restartApp Focused Tests", () => {
         0
       );
       for (let i = 0; i < 50; i++) {
-        await router.restartApp(`/user/${i}`);
+        await router.restartApp("/user/".concat(i));
       }
       const finalAppsCallCount = Object.values(mockApps).reduce(
         (sum, app) => sum + app.mock.calls.length,
@@ -601,7 +601,7 @@ describe("Router.restartApp Focused Tests", () => {
       const startTime = Date.now();
       const promises = Array.from(
         { length: 10 },
-        (_, i) => router.restartApp(`/user/${i}`).catch((err) => err)
+        (_, i) => router.restartApp("/user/".concat(i)).catch((err) => err)
       );
       const results = await Promise.all(promises);
       const endTime = Date.now();

package/dist/router-window-navigation.test.mjs

@@ -33,8 +33,8 @@ describe("Router Window Navigation Tests", () => {
     });
   });
   function createWindowNavigationTests(methodName, expectedIsPush) {
-    describe(`\u{1FA9F} ${methodName} Core Functionality Tests`, () => {
-      it(`should support using current route path`, async () => {
+    describe("\u{1FA9F} ".concat(methodName, " Core Functionality Tests"), () => {
+      it("should support using current route path", async () => {
         await router.push("/about");
         const result = await router[methodName]("/about");
         expect(result.type).toBe(RouteType[methodName]);
@@ -42,7 +42,7 @@ describe("Router Window Navigation Tests", () => {
         expect(result.isPush).toBe(expectedIsPush);
         expect(result.handle).not.toBeNull();
       });
-      it(`should support string path parameters`, async () => {
+      it("should support string path parameters", async () => {
         const result = await router[methodName]("/user/123");
         expect(result.type).toBe(RouteType[methodName]);
         expect(result.path).toBe("/user/123");
@@ -50,7 +50,7 @@ describe("Router Window Navigation Tests", () => {
         expect(result.isPush).toBe(expectedIsPush);
         expect(result.handle).not.toBeNull();
       });
-      it(`should support object parameters`, async () => {
+      it("should support object parameters", async () => {
         const result = await router[methodName]({
           path: "/user/456",
           query: { tab: "profile" },
@@ -64,7 +64,7 @@ describe("Router Window Navigation Tests", () => {
         expect(result.isPush).toBe(expectedIsPush);
         expect(result.handle).not.toBeNull();
       });
-      it(`should correctly handle complete URLs`, async () => {
+      it("should correctly handle complete URLs", async () => {
         const result = await router[methodName](
           "https://example.com/user/789?sort=name#top"
         );
@@ -76,13 +76,13 @@ describe("Router Window Navigation Tests", () => {
         expect(result.handle).not.toBeNull();
       });
     });
-    describe(`\u{1F3AF} ${methodName} Specific Behavior Tests`, () => {
-      it(`should set correct isPush flag`, async () => {
+    describe("\u{1F3AF} ".concat(methodName, " Specific Behavior Tests"), () => {
+      it("should set correct isPush flag", async () => {
         const result = await router[methodName]("/about");
         expect(result.isPush).toBe(expectedIsPush);
         expect(result.type).toBe(RouteType[methodName]);
       });
-      it(`should call location handler`, async () => {
+      it("should call location handler", async () => {
         let locationCalled = false;
         let receivedRoute = null;
         const windowRouter = new Router({
@@ -101,7 +101,7 @@ describe("Router Window Navigation Tests", () => {
         expect(result.handleResult).toEqual({ windowNavigation: true });
         windowRouter.destroy();
       });
-      it(`should not update current route state`, async () => {
+      it("should not update current route state", async () => {
         await router.push("/about");
         const beforeRoute = router.route;
         await router[methodName]("/user/123");
@@ -109,14 +109,14 @@ describe("Router Window Navigation Tests", () => {
         expect(afterRoute.path).toBe(beforeRoute.path);
         expect(afterRoute.url.href).toBe(beforeRoute.url.href);
       });
-      it(`should not trigger MicroApp update`, async () => {
+      it("should not trigger MicroApp update", async () => {
         const updateSpy = vi.spyOn(router.microApp, "_update");
         await router[methodName]("/user/123");
         expect(updateSpy).not.toHaveBeenCalled();
       });
     });
-    describe(`\u{1F6E1}\uFE0F ${methodName} Route Guards Tests`, () => {
-      it(`should execute beforeEach guards`, async () => {
+    describe("\u{1F6E1}\uFE0F ".concat(methodName, " Route Guards Tests"), () => {
+      it("should execute beforeEach guards", async () => {
         let guardCalled = false;
         const unregister = router.beforeEach(async (to, from) => {
           guardCalled = true;
@@ -126,7 +126,7 @@ describe("Router Window Navigation Tests", () => {
         expect(guardCalled).toBe(true);
         unregister();
       });
-      it(`should abort navigation when guard returns false`, async () => {
+      it("should abort navigation when guard returns false", async () => {
         const unregister = router.beforeEach((to, from) => {
           return false;
         });
@@ -135,7 +135,7 @@ describe("Router Window Navigation Tests", () => {
         );
         unregister();
       });
-      it(`should support guard redirects`, async () => {
+      it("should support guard redirects", async () => {
         const unregister = router.beforeEach(async (to) => {
           if (to.path === "/about") {
             return "/user/redirect";
@@ -146,7 +146,7 @@ describe("Router Window Navigation Tests", () => {
         expect(result.params.id).toBe("redirect");
         unregister();
       });
-      it(`should execute afterEach guards`, async () => {
+      it("should execute afterEach guards", async () => {
         let guardCalled = false;
         const unregister = router.afterEach((to, from) => {
           guardCalled = true;
@@ -157,19 +157,19 @@ describe("Router Window Navigation Tests", () => {
         unregister();
       });
     });
-    describe(`\u{1F3AD} ${methodName} Edge Cases Tests`, () => {
-      it(`should handle non-existent routes`, async () => {
+    describe("\u{1F3AD} ".concat(methodName, " Edge Cases Tests"), () => {
+      it("should handle non-existent routes", async () => {
         const result = await router[methodName]("/nonexistent");
         expect(result.handle).not.toBeNull();
         expect(result.matched.length).toBe(0);
         expect(result.isPush).toBe(expectedIsPush);
       });
-      it(`should handle empty string path`, async () => {
+      it("should handle empty string path", async () => {
         const result = await router[methodName]("");
         expect(result.handle).not.toBeNull();
         expect(result.isPush).toBe(expectedIsPush);
       });
-      it(`should handle special characters`, async () => {
+      it("should handle special characters", async () => {
         const result = await router[methodName](
           "/user/\u6D4B\u8BD5\u7528\u6237?name=\u5F20\u4E09&age=25#\u4E2A\u4EBA\u4FE1\u606F"
         );
@@ -180,8 +180,8 @@ describe("Router Window Navigation Tests", () => {
         );
       });
     });
-    describe(`\u26A1 ${methodName} Task Cancellation and Concurrency Control`, () => {
-      it(`should support concurrent calls`, async () => {
+    describe("\u26A1 ".concat(methodName, " Task Cancellation and Concurrency Control"), () => {
+      it("should support concurrent calls", async () => {
         const promises = [
           router[methodName]("/user/1").catch((err) => err),
           router[methodName]("/user/2").catch((err) => err),
@@ -198,10 +198,10 @@ describe("Router Window Navigation Tests", () => {
           expect(result.isPush).toBe(expectedIsPush);
         });
       });
-      it(`should correctly handle rapid consecutive calls`, async () => {
+      it("should correctly handle rapid consecutive calls", async () => {
         const results = [];
         for (let i = 0; i < 5; i++) {
-          results.push(await router[methodName](`/user/${i}`));
+          results.push(await router[methodName]("/user/".concat(i)));
         }
         results.forEach((result, index) => {
           expect(result.handle).not.toBeNull();
@@ -210,15 +210,15 @@ describe("Router Window Navigation Tests", () => {
         });
       });
     });
-    describe(`\u274C ${methodName} Error Handling`, () => {
-      it(`should handle exceptions in guards`, async () => {
+    describe("\u274C ".concat(methodName, " Error Handling"), () => {
+      it("should handle exceptions in guards", async () => {
         const unregister = router.beforeEach(async () => {
           throw new Error("Guard error");
         });
         await expect(router[methodName]("/about")).rejects.toThrow();
         unregister();
       });
-      it(`should handle location handler exceptions`, async () => {
+      it("should handle location handler exceptions", async () => {
         const windowRouter = new Router({
           routes: [{ path: "/", app: "home" }],
           apps: mockApps,
@@ -233,8 +233,8 @@ describe("Router Window Navigation Tests", () => {
         windowRouter.destroy();
       });
     });
-    describe(`\u{1F9E9} ${methodName} Async Component Handling`, () => {
-      it(`should correctly handle async components`, async () => {
+    describe("\u{1F9E9} ".concat(methodName, " Async Component Handling"), () => {
+      it("should correctly handle async components", async () => {
         const asyncRouter = new Router({
           routes: [
             {
@@ -261,7 +261,7 @@ describe("Router Window Navigation Tests", () => {
         expect(result.handleResult).toEqual({ windowNavigation: true });
         asyncRouter.destroy();
       });
-      it(`should handle async component loading failures`, async () => {
+      it("should handle async component loading failures", async () => {
         const asyncRouter = new Router({
           routes: [
             {
@@ -285,8 +285,8 @@ describe("Router Window Navigation Tests", () => {
         asyncRouter.destroy();
       });
     });
-    describe(`\u{1F527} ${methodName} Differences from Other Methods`, () => {
-      it(`should behave differently from push/replace methods`, async () => {
+    describe("\u{1F527} ".concat(methodName, " Differences from Other Methods"), () => {
+      it("should behave differently from push/replace methods", async () => {
         await router.push("/about");
         const pushResult = await router.push("/user/123");
         const windowResult = await router[methodName]("/user/456");
@@ -296,7 +296,7 @@ describe("Router Window Navigation Tests", () => {
         expect(pushResult.type).toBe(RouteType.push);
         expect(windowResult.type).toBe(RouteType[methodName]);
       });
-      it(`should maintain consistency with resolve method in URL parsing`, async () => {
+      it("should maintain consistency with resolve method in URL parsing", async () => {
         const resolvedRoute = router.resolve("/user/789");
         const windowRoute = await router[methodName]("/user/789");
         expect(windowRoute.url.href).toBe(resolvedRoute.url.href);

package/dist/router.mjs

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { LAYER_ID } from "./increment-id.mjs";
 import { MicroApp } from "./micro-app.mjs";
 import { Navigation } from "./navigation.mjs";
@@ -8,13 +11,27 @@ import { createLinkResolver } from "./router-link.mjs";
 import { RouteType, RouterMode } from "./types.mjs";
 import { isNotNullish, isPlainObject, isRouteMatched } from "./util.mjs";
 export class Router {
-  options;
-  parsedOptions;
-  isLayer;
-  navigation;
-  microApp = new MicroApp();
-  // Route transition manager
-  transition = new RouteTransition(this);
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "parsedOptions");
+    __publicField(this, "isLayer");
+    __publicField(this, "navigation");
+    __publicField(this, "microApp", new MicroApp());
+    // Route transition manager
+    __publicField(this, "transition", new RouteTransition(this));
+    this.options = options;
+    this.parsedOptions = parsedOptions(options);
+    this.isLayer = this.parsedOptions.layer;
+    this.navigation = new Navigation(
+      this.parsedOptions,
+      (url, state) => {
+        this.transition.to(RouteType.unknown, {
+          url,
+          state
+        });
+      }
+    );
+  }
   get route() {
     const route = this.transition.route;
     if (route === null) {
@@ -28,24 +45,12 @@ export class Router {
     return this.parsedOptions.root;
   }
   get req() {
-    return this.parsedOptions.req ?? null;
+    var _a;
+    return (_a = this.parsedOptions.req) != null ? _a : null;
   }
   get res() {
-    return this.parsedOptions.res ?? null;
-  }
-  constructor(options) {
-    this.options = options;
-    this.parsedOptions = parsedOptions(options);
-    this.isLayer = this.parsedOptions.layer;
-    this.navigation = new Navigation(
-      this.parsedOptions,
-      (url, state) => {
-        this.transition.to(RouteType.unknown, {
-          url,
-          state
-        });
-      }
-    );
+    var _a;
+    return (_a = this.parsedOptions.res) != null ? _a : null;
   }
   push(toInput) {
     return this.transition.to(RouteType.push, toInput);
@@ -62,7 +67,7 @@ export class Router {
   restartApp(toInput) {
     return this.transition.to(
       RouteType.restartApp,
-      toInput ?? this.route.url.href
+      toInput != null ? toInput : this.route.url.href
     );
   }
   async back() {
@@ -132,12 +137,12 @@ export class Router {
    * ```
    */
   resolve(toInput, toType) {
-    var _a;
+    var _a, _b;
     return new Route({
       options: this.parsedOptions,
       toType,
       toInput,
-      from: ((_a = this.transition.route) == null ? void 0 : _a.url) ?? null
+      from: (_b = (_a = this.transition.route) == null ? void 0 : _a.url) != null ? _b : null
     });
   }
   /**
@@ -194,10 +199,11 @@ export class Router {
     return createLinkResolver(this, props);
   }
   async createLayer(toInput) {
-    const layerOptions = (isPlainObject(toInput) ? toInput.layer : null) || {};
-    const zIndex = layerOptions.zIndex ?? this.parsedOptions.zIndex + LAYER_ID.next();
+    var _a;
+    const layerOptions = isPlainObject(toInput) && toInput.layer || {};
+    const zIndex = (_a = layerOptions.zIndex) != null ? _a : this.parsedOptions.zIndex + LAYER_ID.next();
     let promiseResolve;
-    const promise = new Promise((resolve) => {
+    let promise = new Promise((resolve) => {
       promiseResolve = resolve;
     });
     const router = new Router({
@@ -245,7 +251,7 @@ export class Router {
     router.afterEach((to, from) => {
       if (layerOptions.shouldClose) {
         const result = layerOptions.shouldClose(to, from, router);
-        if (result === false) {
+        if (result === true) {
           router.destroy();
           promiseResolve({
             type: "push",
@@ -259,6 +265,18 @@ export class Router {
         router.route.state,
         router.route.url
       );
+      promise = promise.then(async (result) => {
+        await this.navigation.backHistoryState();
+        return result;
+      });
+    }
+    if (layerOptions.autoPush) {
+      promise = promise.then(async (result) => {
+        if (result.type === "push") {
+          await this.push(result.route.url.href);
+        }
+        return result;
+      });
     }
     return {
       promise,
@@ -277,7 +295,7 @@ export class Router {
     var _a, _b;
     try {
       const result = await ((_b = (_a = this.microApp.app) == null ? void 0 : _a.renderToString) == null ? void 0 : _b.call(_a));
-      return result ?? null;
+      return result != null ? result : null;
     } catch (e) {
       if (throwError) throw e;
       else console.error(e);

package/dist/types.d.ts

@@ -214,6 +214,7 @@ export interface RouterLinkAttributes {
     target?: '_blank';
     rel?: string;
 }
+export type RouterLinkEventHandler = <E extends Event = MouseEvent>(event: E) => boolean | void;
 /**
  * Framework-agnostic link configuration interface
  */
@@ -229,6 +230,7 @@ export interface RouterLinkProps {
     event?: string | string[];
     tag?: string;
     layerOptions?: RouteLayerOptions;
+    eventHandler?: RouterLinkEventHandler;
 }
 /**
  * Framework-agnostic link resolution result
@@ -241,6 +243,6 @@ export interface RouterLinkResolved {
     isExternal: boolean;
     tag: string;
     attributes: RouterLinkAttributes;
-    navigate: (e?: MouseEvent) => Promise<void>;
-    getEventHandlers: (nameTransform?: (eventType: string) => string) => Record<string, (e: MouseEvent) => Promise<void>>;
+    navigate: (e?: Event) => Promise<void>;
+    getEventHandlers: (nameTransform?: (eventType: string) => string) => Record<string, (e: Event) => Promise<void> | undefined>;
 }

package/dist/util.test.mjs

@@ -23,8 +23,8 @@ describe("isNotNullish", () => {
     expect(isNotNullish(new Number("a"))).toBe(false);
     expect(isNotNullish(0)).toBe(true);
     expect(isNotNullish(123)).toBe(true);
-    expect(isNotNullish(123n)).toBe(true);
-    expect(isNotNullish(0n)).toBe(true);
+    expect(isNotNullish(/* @__PURE__ */ BigInt("123"))).toBe(true);
+    expect(isNotNullish(/* @__PURE__ */ BigInt("0"))).toBe(true);
     expect(isNotNullish(new Number("1"))).toBe(true);
     expect(isNotNullish(Number.POSITIVE_INFINITY)).toBe(true);
     expect(isNotNullish(Number.NEGATIVE_INFINITY)).toBe(true);
@@ -171,9 +171,9 @@ describe("isPlainObject", () => {
     expect(isPlainObject(new Boolean(true))).toBe(false);
     expect(isPlainObject(new Boolean(false))).toBe(false);
     expect(isPlainObject(0)).toBe(false);
-    expect(isPlainObject(0n)).toBe(false);
+    expect(isPlainObject(/* @__PURE__ */ BigInt("0"))).toBe(false);
     expect(isPlainObject(123)).toBe(false);
-    expect(isPlainObject(123n)).toBe(false);
+    expect(isPlainObject(/* @__PURE__ */ BigInt("123"))).toBe(false);
     expect(isPlainObject(new Number("1"))).toBe(false);
     expect(isPlainObject(+"a")).toBe(false);
     expect(isPlainObject(Number.NaN)).toBe(false);
@@ -249,8 +249,8 @@ describe("isNonEmptyPlainObject", () => {
     expect(isNonEmptyPlainObject("non-empty")).toBe(false);
     expect(isNonEmptyPlainObject(0)).toBe(false);
     expect(isNonEmptyPlainObject(123)).toBe(false);
-    expect(isNonEmptyPlainObject(0n)).toBe(false);
-    expect(isNonEmptyPlainObject(123n)).toBe(false);
+    expect(isNonEmptyPlainObject(/* @__PURE__ */ BigInt("0"))).toBe(false);
+    expect(isNonEmptyPlainObject(/* @__PURE__ */ BigInt("123"))).toBe(false);
     expect(isNonEmptyPlainObject(true)).toBe(false);
     expect(isNonEmptyPlainObject(false)).toBe(false);
     expect(isNonEmptyPlainObject(Symbol("test"))).toBe(false);
@@ -381,12 +381,12 @@ describe("removeFromArray", () => {
     expect(complexArr).toHaveLength(2);
   });
   test("should handle arrays with different primitive types", () => {
-    let mixedArr = [1, "1", true, 1n, Symbol("test")];
+    let mixedArr = [1, "1", true, /* @__PURE__ */ BigInt("1"), Symbol("test")];
     removeFromArray(mixedArr, 1);
-    expect(mixedArr).toEqual(["1", true, 1n, expect.any(Symbol)]);
-    mixedArr = [1, "1", true, 1n, Symbol("test")];
+    expect(mixedArr).toEqual(["1", true, /* @__PURE__ */ BigInt("1"), expect.any(Symbol)]);
+    mixedArr = [1, "1", true, /* @__PURE__ */ BigInt("1"), Symbol("test")];
     removeFromArray(mixedArr, "1");
-    expect(mixedArr).toEqual([1, true, 1n, expect.any(Symbol)]);
+    expect(mixedArr).toEqual([1, true, /* @__PURE__ */ BigInt("1"), expect.any(Symbol)]);
     const mixedArray = [
       "string",
       42,
@@ -496,8 +496,8 @@ describe("isValidConfirmHookResult", () => {
     expect(isValidConfirmHookResult(void 0)).toBe(false);
     expect(isValidConfirmHookResult(123)).toBe(false);
     expect(isValidConfirmHookResult(0)).toBe(false);
-    expect(isValidConfirmHookResult(123n)).toBe(false);
-    expect(isValidConfirmHookResult(0n)).toBe(false);
+    expect(isValidConfirmHookResult(/* @__PURE__ */ BigInt("123"))).toBe(false);
+    expect(isValidConfirmHookResult(/* @__PURE__ */ BigInt("0"))).toBe(false);
     expect(isValidConfirmHookResult(new Number("1"))).toBe(false);
     expect(isValidConfirmHookResult(+"a")).toBe(false);
     expect(isValidConfirmHookResult(Number.NaN)).toBe(false);
@@ -798,11 +798,11 @@ describe("isUrlEqual", () => {
     const params1 = new URLSearchParams();
     const params2 = new URLSearchParams();
     for (let i = 0; i < 100; i++) {
-      params1.append(`param${i}`, `value${i}`);
-      params2.append(`param${99 - i}`, `value${99 - i}`);
+      params1.append("param".concat(i), "value".concat(i));
+      params2.append("param".concat(99 - i), "value".concat(99 - i));
     }
-    const url1 = new URL(`https://example.com/path?${params1}`);
-    const url2 = new URL(`https://example.com/path?${params2}`);
+    const url1 = new URL("https://example.com/path?".concat(params1));
+    const url2 = new URL("https://example.com/path?".concat(params2));
     const start = performance.now();
     const result = isUrlEqual(url1, url2);
     const end = performance.now();
@@ -812,10 +812,10 @@ describe("isUrlEqual", () => {
   test("should handle complex real-world scenarios", () => {
     const baseUrl = "https://api.example.com/v1/users";
     const url1 = new URL(
-      `${baseUrl}?page=1&limit=20&sort=name&filter=active&tag=user&tag=admin`
+      "".concat(baseUrl, "?page=1&limit=20&sort=name&filter=active&tag=user&tag=admin")
     );
     const url2 = new URL(
-      `${baseUrl}?limit=20&tag=user&page=1&tag=admin&filter=active&sort=name`
+      "".concat(baseUrl, "?limit=20&tag=user&page=1&tag=admin&filter=active&sort=name")
     );
     expect(isUrlEqual(url1, url2)).toBe(true);
     const oauthUrl1 = new URL(

package/package.json

@@ -32,16 +32,16 @@
     },
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
-        "@esmx/lint": "3.0.0-rc.24",
-        "@types/node": "22.15.18",
-        "@vitest/coverage-v8": "3.1.3",
+        "@esmx/lint": "3.0.0-rc.26",
+        "@types/node": "^24.0.10",
+        "@vitest/coverage-v8": "3.2.4",
         "happy-dom": "^18.0.1",
-        "stylelint": "16.19.1",
-        "typescript": "5.8.2",
+        "stylelint": "16.21.0",
+        "typescript": "5.8.3",
         "unbuild": "3.5.0",
-        "vitest": "3.1.3"
+        "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.24",
+    "version": "3.0.0-rc.26",
     "type": "module",
     "private": false,
     "exports": {
@@ -60,5 +60,5 @@
         "template",
         "public"
     ],
-    "gitHead": "ef6208ea42a7105ca056ca9cd3c364d989c4d97d"
+    "gitHead": "2f52f94c8ac27aca32ef3148afd109d0f0470d52"
 }

package/src/navigation.ts

@@ -86,7 +86,11 @@ export class Navigation {
         this._replace(history, data, url);
     }
 
-    public go(index: number): Promise<NavigationGoResult> {
+    public backHistoryState() {
+        return this._go(history, -1);
+    }
+
+    private _go(history: History, index: number): Promise<NavigationGoResult> {
         if (this._promiseResolve) {
             return Promise.resolve(null);
         }
@@ -97,9 +101,12 @@ export class Navigation {
                 resolve({ type: 'success', url, state: state || {} });
             };
             setTimeout(this._promiseResolve, 80);
-            this._history.go(index);
+            history.go(index);
         });
     }
+    public go(delta?: number): Promise<NavigationGoResult> {
+        return this._go(this._history, delta || 0);
+    }
     public forward(): Promise<NavigationGoResult> {
         return this.go(1);
     }

package/src/route-transition.ts

@@ -380,7 +380,7 @@ export class RouteTransition {
         toType: RouteType,
         toInput: RouteLocationInput
     ): Promise<Route> {
-        const from = this.route;
+        const from = this.route?.clone() ?? null;
         const to = await this._runTask(
             new Route({
                 options: this.router.parsedOptions,