@esmx/router 3.0.0-rc.27 → 3.0.0-rc.30

package/dist/util.test.mjs

@@ -1,1020 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { parsedOptions } from "./options.mjs";
-import { Route } from "./route.mjs";
-import { RouteType } from "./types.mjs";
-import {
-  isNonEmptyPlainObject,
-  isNotNullish,
-  isPlainObject,
-  isRouteMatched,
-  isUrlEqual,
-  isValidConfirmHookResult,
-  removeFromArray
-} from "./util.mjs";
-const AsyncFunction = (async () => {
-}).constructor;
-describe("isNotNullish", () => {
-  test("should return true for non-nullish values", () => {
-    expect(isNotNullish(null)).toBe(false);
-    expect(isNotNullish(void 0)).toBe(false);
-    expect(isNotNullish(+"a")).toBe(false);
-    expect(isNotNullish(Number.NaN)).toBe(false);
-    expect(isNotNullish(Number("a"))).toBe(false);
-    expect(isNotNullish(new Number("a"))).toBe(false);
-    expect(isNotNullish(0)).toBe(true);
-    expect(isNotNullish(123)).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);
-    expect(isNotNullish(Number.EPSILON)).toBe(true);
-    expect(isNotNullish("")).toBe(true);
-    expect(isNotNullish("0")).toBe(true);
-    expect(isNotNullish("1")).toBe(true);
-    expect(isNotNullish("test")).toBe(true);
-    expect(isNotNullish(new String(""))).toBe(true);
-    expect(isNotNullish(new String("0"))).toBe(true);
-    expect(isNotNullish(new String("1"))).toBe(true);
-    expect(isNotNullish(new String("test"))).toBe(true);
-    expect(isNotNullish(true)).toBe(true);
-    expect(isNotNullish(false)).toBe(true);
-    expect(isNotNullish(new Boolean(true))).toBe(true);
-    expect(isNotNullish(new Boolean(false))).toBe(true);
-    expect(isNotNullish({})).toBe(true);
-    expect(isNotNullish({ key: "value" })).toBe(true);
-    expect(isNotNullish(new Object())).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ Object.create(null))).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ Object.create({}))).toBe(true);
-    expect(isNotNullish(Object.create(Object.prototype))).toBe(true);
-    expect(isNotNullish({ __proto__: null })).toBe(true);
-    expect(isNotNullish({ [Symbol.toStringTag]: "Tag" })).toBe(true);
-    expect(isNotNullish({ toString: () => "[object CustomObject]" })).toBe(
-      true
-    );
-    expect(isNotNullish([])).toBe(true);
-    expect(isNotNullish(["a", "b"])).toBe(true);
-    expect(isNotNullish(new Array())).toBe(true);
-    expect(isNotNullish(new Array(1, 2, 3))).toBe(true);
-    expect(isNotNullish(new Array(1))).toBe(true);
-    expect(isNotNullish(new Uint8Array(8))).toBe(true);
-    expect(isNotNullish(new ArrayBuffer(8))).toBe(true);
-    expect(isNotNullish(new DataView(new ArrayBuffer(8)))).toBe(true);
-    expect(isNotNullish(() => {
-    })).toBe(true);
-    expect(isNotNullish(async () => {
-    })).toBe(true);
-    expect(isNotNullish(new Function("return 1;"))).toBe(true);
-    expect(isNotNullish(AsyncFunction("return 1;"))).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ new Date())).toBe(true);
-    expect(isNotNullish(Symbol("test"))).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ new Map())).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ new Set())).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ new WeakMap())).toBe(true);
-    expect(isNotNullish(/* @__PURE__ */ new WeakSet())).toBe(true);
-    expect(isNotNullish(/test/)).toBe(true);
-    expect(isNotNullish(new Error("test"))).toBe(true);
-    expect(isNotNullish(Promise.resolve())).toBe(true);
-    expect(isNotNullish(new URL("https://example.com"))).toBe(true);
-    expect(isNotNullish(new URLSearchParams("key=value"))).toBe(true);
-    expect(isNotNullish(new Blob(["test"]))).toBe(true);
-    expect(isNotNullish(new File(["test"], "file.txt"))).toBe(true);
-    expect(isNotNullish(Math)).toBe(true);
-    expect(isNotNullish(JSON)).toBe(true);
-    expect(isNotNullish(console)).toBe(true);
-  });
-  test("should handle edge cases with Number constructor", () => {
-    expect(isNotNullish(Number())).toBe(true);
-    expect(isNotNullish(Number(void 0))).toBe(false);
-    expect(isNotNullish(Number(null))).toBe(true);
-    expect(isNotNullish(Number(""))).toBe(true);
-    expect(isNotNullish(Number("0"))).toBe(true);
-    expect(isNotNullish(Number("123"))).toBe(true);
-    expect(isNotNullish(new Number())).toBe(true);
-    expect(isNotNullish(new Number(void 0))).toBe(false);
-    expect(isNotNullish(new Number(null))).toBe(true);
-    expect(isNotNullish(new Number(""))).toBe(true);
-    expect(isNotNullish(new Number("0"))).toBe(true);
-    expect(isNotNullish(new Number("123"))).toBe(true);
-  });
-  test("should handle various NaN cases", () => {
-    expect(isNotNullish(0 / 0)).toBe(false);
-    expect(isNotNullish(Math.sqrt(-1))).toBe(false);
-    expect(isNotNullish(Number.parseInt("abc"))).toBe(false);
-    expect(isNotNullish(Number.parseFloat("abc"))).toBe(false);
-    expect(isNotNullish(Number.NaN)).toBe(false);
-    expect(isNotNullish(Number.NaN)).toBe(false);
-    expect(isNotNullish(new Number(Number.NaN))).toBe(false);
-    expect(isNotNullish(new Number(0 / 0))).toBe(false);
-    expect(isNotNullish(new Number(Number.parseInt("abc")))).toBe(false);
-  });
-  test("should handle complex objects", () => {
-    class CustomClass {
-      constructor(value) {
-        this.value = value;
-      }
-    }
-    expect(isNotNullish(new CustomClass(123))).toBe(true);
-    const frozenObj = Object.freeze({ a: 1 });
-    const sealedObj = Object.seal({ b: 2 });
-    expect(isNotNullish(frozenObj)).toBe(true);
-    expect(isNotNullish(sealedObj)).toBe(true);
-    const objWithDescriptor = {};
-    Object.defineProperty(objWithDescriptor, "prop", {
-      value: "test",
-      writable: false
-    });
-    expect(isNotNullish(objWithDescriptor)).toBe(true);
-  });
-});
-describe("isPlainObject", () => {
-  test("should return true for plain objects", () => {
-    expect(isPlainObject({})).toBe(true);
-    expect(isPlainObject({ key: "value" })).toBe(true);
-    expect(isPlainObject(new Object())).toBe(true);
-    expect(isPlainObject(/* @__PURE__ */ Object.create(null))).toBe(true);
-    expect(isPlainObject(/* @__PURE__ */ Object.create({}))).toBe(true);
-    expect(isPlainObject(Object.create(Object.prototype))).toBe(true);
-    expect(isPlainObject(/* @__PURE__ */ Object.create({ parent: "value" }))).toBe(true);
-    expect(isPlainObject({ __proto__: null })).toBe(true);
-    expect(isPlainObject({ [Symbol.toStringTag]: "Tag" })).toBe(true);
-    expect(isPlainObject({ toString: () => "[object CustomObject]" })).toBe(
-      true
-    );
-    expect(isPlainObject(Math)).toBe(true);
-    expect(isPlainObject(JSON)).toBe(true);
-    class TestClass {
-    }
-    expect(isPlainObject(new TestClass())).toBe(true);
-  });
-  test("should return false for non-plain objects", () => {
-    expect(isPlainObject(null)).toBe(false);
-    expect(isPlainObject(void 0)).toBe(false);
-    expect(isPlainObject([])).toBe(false);
-    expect(isPlainObject(["a", "b"])).toBe(false);
-    expect(isPlainObject(new Array())).toBe(false);
-    expect(isPlainObject(new Array(1, 2, 3))).toBe(false);
-    expect(isPlainObject(new Array(1))).toBe(false);
-    expect(isPlainObject(new Uint8Array(8))).toBe(false);
-    expect(isPlainObject(new ArrayBuffer(8))).toBe(false);
-    expect(isPlainObject(new DataView(new ArrayBuffer(8)))).toBe(false);
-    expect(isPlainObject("")).toBe(false);
-    expect(isPlainObject("0")).toBe(false);
-    expect(isPlainObject("1")).toBe(false);
-    expect(isPlainObject("string")).toBe(false);
-    expect(isPlainObject(new String(""))).toBe(false);
-    expect(isPlainObject(new String("0"))).toBe(false);
-    expect(isPlainObject(new String("1"))).toBe(false);
-    expect(isPlainObject(new String("string"))).toBe(false);
-    expect(isPlainObject(true)).toBe(false);
-    expect(isPlainObject(false)).toBe(false);
-    expect(isPlainObject(new Boolean(true))).toBe(false);
-    expect(isPlainObject(new Boolean(false))).toBe(false);
-    expect(isPlainObject(0)).toBe(false);
-    expect(isPlainObject(/* @__PURE__ */ BigInt("0"))).toBe(false);
-    expect(isPlainObject(123)).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);
-    expect(isPlainObject(new Number("a"))).toBe(false);
-    expect(isPlainObject(() => {
-    })).toBe(false);
-    expect(isPlainObject(async () => {
-    })).toBe(false);
-    expect(isPlainObject(new Function("return 1;"))).toBe(false);
-    expect(isPlainObject(AsyncFunction("return 1;"))).toBe(false);
-    expect(isPlainObject(/* @__PURE__ */ new Date())).toBe(false);
-    expect(isPlainObject(Symbol("test"))).toBe(false);
-    expect(isPlainObject(/* @__PURE__ */ new Map())).toBe(false);
-    expect(isPlainObject(/* @__PURE__ */ new Set())).toBe(false);
-    expect(isPlainObject(/* @__PURE__ */ new WeakMap())).toBe(false);
-    expect(isPlainObject(/* @__PURE__ */ new WeakSet())).toBe(false);
-    expect(isPlainObject(/test/)).toBe(false);
-    expect(isPlainObject(new Error("test"))).toBe(false);
-    expect(isPlainObject(Promise.resolve())).toBe(false);
-    expect(isPlainObject(new URL("https://example.com"))).toBe(false);
-    expect(isPlainObject(new URLSearchParams("key=value"))).toBe(false);
-    expect(isPlainObject(new Blob(["test"]))).toBe(false);
-    expect(isPlainObject(new File(["test"], "file.txt"))).toBe(false);
-  });
-  test("should distinguish between objects and boxed primitives", () => {
-    expect(isPlainObject(Object(42))).toBe(false);
-    expect(isPlainObject(Object("str"))).toBe(false);
-    expect(isPlainObject(Object(true))).toBe(false);
-    expect(isPlainObject(Object(Symbol("sym")))).toBe(false);
-  });
-});
-describe("isNonEmptyPlainObject", () => {
-  test("should return true for non-empty plain objects", () => {
-    expect(isNonEmptyPlainObject({ key: "value" })).toBe(true);
-    expect(isNonEmptyPlainObject({ a: 1, b: 2 })).toBe(true);
-    expect(isNonEmptyPlainObject({ nested: { value: "test" } })).toBe(true);
-    expect(
-      isNonEmptyPlainObject({ toString: () => "[object CustomObject]" })
-    ).toBe(true);
-    const obj = new Object();
-    obj.prop = "value";
-    expect(isNonEmptyPlainObject(obj)).toBe(true);
-    const objWithProto = /* @__PURE__ */ Object.create({ parent: "value" });
-    objWithProto.own = "property";
-    expect(isNonEmptyPlainObject(objWithProto)).toBe(true);
-    class TestClass {
-    }
-    const instance = new TestClass();
-    instance.prop = "value";
-    expect(isNonEmptyPlainObject(instance)).toBe(true);
-  });
-  test("should return false for empty objects", () => {
-    expect(isNonEmptyPlainObject({})).toBe(false);
-    expect(isNonEmptyPlainObject(new Object())).toBe(false);
-    expect(isNonEmptyPlainObject(/* @__PURE__ */ Object.create(null))).toBe(false);
-    expect(isNonEmptyPlainObject(/* @__PURE__ */ Object.create({}))).toBe(false);
-    expect(isNonEmptyPlainObject(Object.create(Object.prototype))).toBe(
-      false
-    );
-    expect(isNonEmptyPlainObject({ __proto__: null })).toBe(false);
-    class TestClass {
-    }
-    expect(isNonEmptyPlainObject(new TestClass())).toBe(false);
-    expect(isNonEmptyPlainObject({ [Symbol.toStringTag]: "Tag" })).toBe(
-      false
-    );
-    expect(isNonEmptyPlainObject({ [Symbol("key")]: "value" })).toBe(false);
-  });
-  test("should return false for non-objects", () => {
-    expect(isNonEmptyPlainObject(null)).toBe(false);
-    expect(isNonEmptyPlainObject(void 0)).toBe(false);
-    expect(isNonEmptyPlainObject("")).toBe(false);
-    expect(isNonEmptyPlainObject("non-empty")).toBe(false);
-    expect(isNonEmptyPlainObject(0)).toBe(false);
-    expect(isNonEmptyPlainObject(123)).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);
-    expect(isNonEmptyPlainObject([])).toBe(false);
-    expect(isNonEmptyPlainObject(["a", "b"])).toBe(false);
-    expect(isNonEmptyPlainObject(() => {
-    })).toBe(false);
-    expect(isNonEmptyPlainObject(async () => {
-    })).toBe(false);
-    expect(isNonEmptyPlainObject(/* @__PURE__ */ new Date())).toBe(false);
-    expect(isNonEmptyPlainObject(/* @__PURE__ */ new Map())).toBe(false);
-    expect(isNonEmptyPlainObject(/* @__PURE__ */ new Set())).toBe(false);
-    expect(isNonEmptyPlainObject(/test/)).toBe(false);
-    expect(isNonEmptyPlainObject(new Error("test"))).toBe(false);
-    expect(isNonEmptyPlainObject(Promise.resolve())).toBe(false);
-    expect(isNonEmptyPlainObject(new String("test"))).toBe(false);
-    expect(isNonEmptyPlainObject(new Number(123))).toBe(false);
-    expect(isNonEmptyPlainObject(new Boolean(true))).toBe(false);
-  });
-  test("should handle objects with only inherited properties", () => {
-    const parentObj = { parentProp: "value" };
-    const childObj = Object.create(parentObj);
-    expect(isNonEmptyPlainObject(childObj)).toBe(false);
-    childObj.ownProp = "own";
-    expect(isNonEmptyPlainObject(childObj)).toBe(true);
-  });
-  test("should handle edge cases", () => {
-    const objWithNonEnum = {};
-    Object.defineProperty(objWithNonEnum, "nonEnum", {
-      value: "hidden",
-      enumerable: false
-    });
-    expect(isNonEmptyPlainObject(objWithNonEnum)).toBe(false);
-    Object.defineProperty(objWithNonEnum, "visible", {
-      value: "visible",
-      enumerable: true
-    });
-    expect(isNonEmptyPlainObject(objWithNonEnum)).toBe(true);
-    const frozenObj = Object.freeze({ prop: "value" });
-    expect(isNonEmptyPlainObject(frozenObj)).toBe(true);
-    const sealedObj = Object.seal({ prop: "value" });
-    expect(isNonEmptyPlainObject(sealedObj)).toBe(true);
-  });
-});
-describe("removeFromArray", () => {
-  test("should remove first occurrence when duplicates exist", () => {
-    const arr = [1, 2, 2, 3];
-    removeFromArray(arr, 2);
-    expect(arr).toEqual([1, 2, 3]);
-    const num = new Number(2);
-    let arrWithObj = [1, num, 2, 3];
-    removeFromArray(arrWithObj, 2);
-    expect(arrWithObj).toEqual([1, num, 3]);
-    arrWithObj = [1, num, 2, 3];
-    removeFromArray(arrWithObj, num);
-    expect(arrWithObj).toEqual([1, 2, 3]);
-    arrWithObj = [1, 2, num, 3];
-    removeFromArray(arrWithObj, num);
-    expect(arrWithObj).toEqual([1, 2, 3]);
-    arrWithObj = [1, 2, num, 3];
-    removeFromArray(arrWithObj, 2);
-    expect(arrWithObj).toEqual([1, num, 3]);
-    arrWithObj = [1, num, num, 3];
-    removeFromArray(arrWithObj, num);
-    expect(arrWithObj).toEqual([1, num, 3]);
-  });
-  test("should remove existing element from array", () => {
-    const arr = [1, 2, 3];
-    removeFromArray(arr, 2);
-    expect(arr).toEqual([1, 3]);
-  });
-  test("should do nothing when element not found", () => {
-    const arr = [1, 2, 3];
-    removeFromArray(arr, 4);
-    expect(arr).toEqual([1, 2, 3]);
-  });
-  test("should work with object references", () => {
-    const obj1 = { id: 1 };
-    const obj2 = { id: 2 };
-    const arr = [obj1, obj2];
-    removeFromArray(arr, obj1);
-    expect(arr).toEqual([obj2]);
-  });
-  test("should handle edge cases", () => {
-    const emptyArr = [];
-    removeFromArray(emptyArr, 1);
-    expect(emptyArr).toEqual([]);
-    const singleArr = [42];
-    removeFromArray(singleArr, 42);
-    expect(singleArr).toEqual([]);
-    const singleArr2 = [42];
-    removeFromArray(singleArr2, 99);
-    expect(singleArr2).toEqual([42]);
-    const sameArr = [5, 5, 5, 5];
-    removeFromArray(sameArr, 5);
-    expect(sameArr).toEqual([5, 5, 5]);
-    const nullishArr = [1, null, void 0, 2];
-    removeFromArray(nullishArr, null);
-    expect(nullishArr).toEqual([1, void 0, 2]);
-    const nullishArr2 = [1, null, void 0, 2];
-    removeFromArray(nullishArr2, void 0);
-    expect(nullishArr2).toEqual([1, null, 2]);
-  });
-  test("should handle NaN correctly", () => {
-    const nanArr = [1, Number.NaN, 2, Number.NaN];
-    removeFromArray(nanArr, Number.NaN);
-    expect(nanArr).toEqual([1, 2, Number.NaN]);
-  });
-  test("should handle sparse arrays", () => {
-    const sparseArr = [1, , 3, , 5];
-    removeFromArray(sparseArr, void 0);
-    expect(sparseArr).toHaveLength(5);
-    expect(sparseArr).toEqual([1, , 3, , 5]);
-  });
-  test("should handle arrays with complex objects", () => {
-    const complexArr = [
-      { id: 1, nested: { value: "a" } },
-      { id: 2, nested: { value: "b" } },
-      { id: 1, nested: { value: "a" } }
-      // Same content but different reference
-    ];
-    const targetObj = complexArr[0];
-    removeFromArray(complexArr, targetObj);
-    expect(complexArr).toHaveLength(2);
-    expect(complexArr[0]).toEqual({ id: 2, nested: { value: "b" } });
-    expect(complexArr[1]).toEqual({ id: 1, nested: { value: "a" } });
-    removeFromArray(complexArr, { id: 1, nested: { value: "a" } });
-    expect(complexArr).toHaveLength(2);
-  });
-  test("should handle arrays with different primitive types", () => {
-    let mixedArr = [1, "1", true, /* @__PURE__ */ BigInt("1"), Symbol("test")];
-    removeFromArray(mixedArr, 1);
-    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, /* @__PURE__ */ BigInt("1"), expect.any(Symbol)]);
-    const mixedArray = [
-      "string",
-      42,
-      true,
-      null,
-      void 0,
-      { obj: "value" },
-      [1, 2, 3],
-      Symbol("test"),
-      () => "fn",
-      /* @__PURE__ */ new Date(),
-      /regex/,
-      /* @__PURE__ */ new Map(),
-      /* @__PURE__ */ new Set()
-    ];
-    const originalLength = mixedArray.length;
-    removeFromArray(mixedArray, "nonexistent");
-    expect(mixedArray).toHaveLength(originalLength);
-    removeFromArray(mixedArray, 42);
-    expect(mixedArray).toHaveLength(originalLength - 1);
-    expect(mixedArray.includes(42)).toBe(false);
-  });
-  test("should preserve array structure", () => {
-    const arr = [1, 2, 3];
-    arr.customProperty = "test";
-    removeFromArray(arr, 2);
-    expect(arr.length).toBe(2);
-    expect(arr[0]).toBe(1);
-    expect(arr[1]).toBe(3);
-    expect(arr).toHaveProperty("customProperty", "test");
-    expect(arr.customProperty).toBe("test");
-  });
-  test("should handle array with getter/setter elements", () => {
-    const arr = [1, 2, 3];
-    Object.defineProperty(arr, "1", {
-      get() {
-        return "getter";
-      },
-      set() {
-      },
-      enumerable: true
-    });
-    removeFromArray(arr, "getter");
-    expect(arr).toHaveLength(2);
-    expect(arr[0]).toBe(1);
-    expect(arr[1]).toBe("getter");
-  });
-  test("should handle strict equality in removeFromArray", () => {
-    const obj1 = { id: 1 };
-    const obj2 = { id: 1 };
-    const arr = [obj1, obj2];
-    removeFromArray(arr, obj1);
-    expect(arr).toHaveLength(1);
-    expect(arr[0]).toBe(obj2);
-    removeFromArray(arr, { id: 1 });
-    expect(arr).toHaveLength(1);
-  });
-});
-describe("isValidConfirmHookResult", () => {
-  test("should return true for boolean values", () => {
-    expect(isValidConfirmHookResult(true)).toBe(false);
-    expect(isValidConfirmHookResult(false)).toBe(true);
-    expect(isValidConfirmHookResult(new Boolean(true))).toBe(false);
-    expect(isValidConfirmHookResult(new Boolean(false))).toBe(false);
-  });
-  test("should return true for string values", () => {
-    expect(isValidConfirmHookResult("")).toBe(true);
-    expect(isValidConfirmHookResult("0")).toBe(true);
-    expect(isValidConfirmHookResult("1")).toBe(true);
-    expect(isValidConfirmHookResult("test")).toBe(true);
-    expect(isValidConfirmHookResult(new String(""))).toBe(false);
-    expect(isValidConfirmHookResult(new String("0"))).toBe(false);
-    expect(isValidConfirmHookResult(new String("1"))).toBe(false);
-    expect(isValidConfirmHookResult(new String("test"))).toBe(false);
-  });
-  test("should return true for function values", () => {
-    expect(isValidConfirmHookResult(() => {
-    })).toBe(true);
-    expect(isValidConfirmHookResult(async () => {
-    })).toBe(true);
-    expect(isValidConfirmHookResult(new Function("return 1;"))).toBe(true);
-    expect(isValidConfirmHookResult(AsyncFunction("return 1;"))).toBe(true);
-  });
-  test("should return true for plain objects", () => {
-    expect(isValidConfirmHookResult({})).toBe(true);
-    expect(isValidConfirmHookResult({ key: "value" })).toBe(true);
-    expect(isValidConfirmHookResult(new Object())).toBe(true);
-    expect(isValidConfirmHookResult(/* @__PURE__ */ Object.create(null))).toBe(true);
-    expect(isValidConfirmHookResult(/* @__PURE__ */ Object.create({}))).toBe(true);
-    expect(isValidConfirmHookResult(Object.create(Object.prototype))).toBe(
-      true
-    );
-    expect(isValidConfirmHookResult({ __proto__: null })).toBe(true);
-    expect(isValidConfirmHookResult({ [Symbol.toStringTag]: "Tag" })).toBe(
-      true
-    );
-    expect(
-      isValidConfirmHookResult({
-        toString: () => "[object CustomObject]"
-      })
-    ).toBe(true);
-    expect(isValidConfirmHookResult(Math)).toBe(true);
-    expect(isValidConfirmHookResult(JSON)).toBe(true);
-  });
-  test("should return false for invalid types", () => {
-    expect(isValidConfirmHookResult(null)).toBe(false);
-    expect(isValidConfirmHookResult(void 0)).toBe(false);
-    expect(isValidConfirmHookResult(123)).toBe(false);
-    expect(isValidConfirmHookResult(0)).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);
-    expect(isValidConfirmHookResult(new Number("a"))).toBe(false);
-    expect(isValidConfirmHookResult([])).toBe(false);
-    expect(isValidConfirmHookResult(["a", "b"])).toBe(false);
-    expect(isValidConfirmHookResult(new Array())).toBe(false);
-    expect(isValidConfirmHookResult(new Array(1, 2, 3))).toBe(false);
-    expect(isValidConfirmHookResult(new Array(1))).toBe(false);
-    expect(isValidConfirmHookResult(new Uint8Array(8))).toBe(false);
-    expect(isValidConfirmHookResult(new ArrayBuffer(8))).toBe(false);
-    expect(isValidConfirmHookResult(new DataView(new ArrayBuffer(8)))).toBe(
-      false
-    );
-    expect(isValidConfirmHookResult(/* @__PURE__ */ new Date())).toBe(false);
-    expect(isValidConfirmHookResult(Symbol("test"))).toBe(false);
-    expect(isValidConfirmHookResult(/* @__PURE__ */ new Map())).toBe(false);
-    expect(isValidConfirmHookResult(/* @__PURE__ */ new Set())).toBe(false);
-    expect(isValidConfirmHookResult(/* @__PURE__ */ new WeakMap())).toBe(false);
-    expect(isValidConfirmHookResult(/* @__PURE__ */ new WeakSet())).toBe(false);
-    expect(isValidConfirmHookResult(/test/)).toBe(false);
-    expect(isValidConfirmHookResult(new Error("test"))).toBe(false);
-    expect(isValidConfirmHookResult(Promise.resolve())).toBe(false);
-    expect(isValidConfirmHookResult(new URL("https://example.com"))).toBe(
-      false
-    );
-    expect(isValidConfirmHookResult(new URLSearchParams("key=value"))).toBe(
-      false
-    );
-    expect(isValidConfirmHookResult(new Blob(["test"]))).toBe(false);
-    expect(isValidConfirmHookResult(new File(["test"], "file.txt"))).toBe(
-      false
-    );
-  });
-  test("should handle edge cases for confirmation hook results", () => {
-    expect(isValidConfirmHookResult(Promise.resolve(true))).toBe(false);
-    const rejectedPromise = Promise.reject(false);
-    rejectedPromise.catch(() => {
-    });
-    expect(isValidConfirmHookResult(rejectedPromise)).toBe(false);
-    const asyncFn = async () => true;
-    expect(isValidConfirmHookResult(asyncFn)).toBe(true);
-    expect(isValidConfirmHookResult((x) => x > 0)).toBe(true);
-    expect(isValidConfirmHookResult((x) => x > 0)).toBe(true);
-    expect(
-      isValidConfirmHookResult(function* () {
-        yield 1;
-      })
-    ).toBe(true);
-    class TestClass {
-    }
-    expect(isValidConfirmHookResult(TestClass)).toBe(true);
-  });
-  test("should handle objects with Symbol properties", () => {
-    const symKey = Symbol("key");
-    const objWithSymbol = { [symKey]: "value", regular: "prop" };
-    expect(isValidConfirmHookResult(objWithSymbol)).toBe(true);
-    const objWithToStringTag = { [Symbol.toStringTag]: "CustomObject" };
-    expect(isValidConfirmHookResult(objWithToStringTag)).toBe(true);
-  });
-  test("should handle frozen and sealed objects", () => {
-    const frozenObj = Object.freeze({ frozen: true });
-    expect(isValidConfirmHookResult(frozenObj)).toBe(true);
-    const sealedObj = Object.seal({ sealed: true });
-    expect(isValidConfirmHookResult(sealedObj)).toBe(true);
-    const nonExtensibleObj = Object.preventExtensions({
-      nonExtensible: true
-    });
-    expect(isValidConfirmHookResult(nonExtensibleObj)).toBe(true);
-  });
-  test("should handle function edge cases", () => {
-    const originalFn = function(x) {
-      return this.value + x;
-    };
-    const boundFn = originalFn.bind({ value: 10 });
-    expect(isValidConfirmHookResult(boundFn)).toBe(true);
-    expect(isValidConfirmHookResult(originalFn.call)).toBe(true);
-    expect(isValidConfirmHookResult(originalFn.apply)).toBe(true);
-    expect(isValidConfirmHookResult(console.log)).toBe(true);
-    expect(isValidConfirmHookResult(Math.max)).toBe(true);
-    expect(isValidConfirmHookResult(Array.prototype.push)).toBe(true);
-  });
-  test("should handle class and constructor edge cases", () => {
-    class TestClass {
-      constructor(value) {
-        this.value = value;
-      }
-    }
-    expect(isValidConfirmHookResult(new TestClass(42))).toBe(true);
-    class ChildClass extends TestClass {
-    }
-    expect(isValidConfirmHookResult(new ChildClass(42))).toBe(true);
-    expect(isValidConfirmHookResult(new Error("test"))).toBe(false);
-    expect(isValidConfirmHookResult(new TypeError("test"))).toBe(false);
-  });
-});
-describe("Performance Tests", () => {
-  test("should handle large arrays efficiently in removeFromArray", () => {
-    const largeArray = Array.from({ length: 1e4 }, (_, i) => i);
-    const target = 5e3;
-    const start = performance.now();
-    removeFromArray(largeArray, target);
-    const end = performance.now();
-    expect(largeArray).toHaveLength(9999);
-    expect(largeArray.includes(target)).toBe(false);
-    expect(end - start).toBeLessThan(100);
-  });
-  test("should handle multiple rapid calls to utility functions", () => {
-    const iterations = 1e3;
-    const start = performance.now();
-    for (let i = 0; i < iterations; ++i) {
-      isNotNullish(i);
-      isPlainObject({ value: i });
-      isValidConfirmHookResult(false);
-    }
-    const end = performance.now();
-    expect(end - start).toBeLessThan(50);
-  });
-  test("should handle rapid array modifications", () => {
-    const arr = [1, 2, 3, 4, 5];
-    const start = performance.now();
-    removeFromArray(arr, 3);
-    removeFromArray(arr, 1);
-    removeFromArray(arr, 5);
-    removeFromArray(arr, 99);
-    const end = performance.now();
-    expect(arr).toEqual([2, 4]);
-    expect(end - start).toBeLessThan(10);
-  });
-});
-describe("Error Handling Tests", () => {
-  test("should handle circular references in objects", () => {
-    const circularObj = { name: "circular" };
-    circularObj.self = circularObj;
-    expect(() => isPlainObject(circularObj)).not.toThrow();
-    expect(() => isValidConfirmHookResult(circularObj)).not.toThrow();
-    expect(() => isNotNullish(circularObj)).not.toThrow();
-    expect(isPlainObject(circularObj)).toBe(true);
-    expect(isValidConfirmHookResult(circularObj)).toBe(true);
-    expect(isNotNullish(circularObj)).toBe(true);
-  });
-});
-describe("isUrlEqual", () => {
-  test("should return false when url2 is null or undefined", () => {
-    const url1 = new URL("https://example.com/path");
-    expect(isUrlEqual(url1, null)).toBe(false);
-    expect(isUrlEqual(url1, void 0)).toBe(false);
-    expect(isUrlEqual(url1)).toBe(false);
-    const urlWithQuery = new URL("https://example.com/path?a=1&b=2");
-    expect(isUrlEqual(urlWithQuery, null)).toBe(false);
-    expect(isUrlEqual(urlWithQuery, void 0)).toBe(false);
-    expect(isUrlEqual(urlWithQuery)).toBe(false);
-    const urlWithHash = new URL("https://example.com/path#section");
-    expect(isUrlEqual(urlWithHash, null)).toBe(false);
-    expect(isUrlEqual(urlWithHash)).toBe(false);
-    const urlWithUserInfo = new URL("https://user:pass@example.com/path");
-    expect(isUrlEqual(urlWithUserInfo, null)).toBe(false);
-    expect(isUrlEqual(urlWithUserInfo)).toBe(false);
-  });
-  test("should return true for identical URL objects", () => {
-    const url1 = new URL("https://example.com/path?a=1&b=2");
-    const url2 = new URL("https://example.com/path?a=1&b=2");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-  });
-  test("should return true for same reference", () => {
-    const url = new URL("https://example.com/path");
-    expect(isUrlEqual(url, url)).toBe(true);
-  });
-  test("should return false for different protocols", () => {
-    const url1 = new URL("http://example.com/path");
-    const url2 = new URL("https://example.com/path");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should return false for different hostnames", () => {
-    const url1 = new URL("https://example.com/path");
-    const url2 = new URL("https://test.com/path");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should return false for different ports", () => {
-    const url1 = new URL("https://example.com:8080/path");
-    const url2 = new URL("https://example.com:9090/path");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should return false for different pathnames", () => {
-    const url1 = new URL("https://example.com/path1");
-    const url2 = new URL("https://example.com/path2");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should return false for different hashes", () => {
-    const url1 = new URL("https://example.com/path#section1");
-    const url2 = new URL("https://example.com/path#section2");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should handle empty hashes correctly", () => {
-    const url1 = new URL("https://example.com/path");
-    const url2 = new URL("https://example.com/path#");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-  });
-  test("should ignore query parameter order", () => {
-    const url1 = new URL("https://example.com/path?a=1&b=2&c=3");
-    const url2 = new URL("https://example.com/path?c=3&a=1&b=2");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-  });
-  test("should handle duplicate query parameters correctly", () => {
-    const url1 = new URL("https://example.com/path?a=1&a=2&b=3");
-    const url2 = new URL("https://example.com/path?b=3&a=2&a=1");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should return false for different duplicate parameter values", () => {
-    const url1 = new URL("https://example.com/path?a=1&a=2");
-    const url2 = new URL("https://example.com/path?a=1&a=3");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should return false for different number of duplicate parameters", () => {
-    const url1 = new URL("https://example.com/path?a=1&a=2");
-    const url2 = new URL("https://example.com/path?a=1");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should handle complex query parameter scenarios", () => {
-    const url1 = new URL(
-      "https://example.com/path?tag=red&tag=blue&category=tech&tag=green"
-    );
-    const url2 = new URL(
-      "https://example.com/path?category=tech&tag=blue&tag=green&tag=red"
-    );
-    expect(isUrlEqual(url1, url2)).toBe(false);
-    const url3 = new URL(
-      "https://example.com/path?search=hello%20world&filter=a%26b"
-    );
-    const url4 = new URL(
-      "https://example.com/path?filter=a%26b&search=hello%20world"
-    );
-    expect(isUrlEqual(url3, url4)).toBe(true);
-  });
-  test("should handle empty query parameters", () => {
-    const url1 = new URL("https://example.com/path?");
-    const url2 = new URL("https://example.com/path");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const url3 = new URL("https://example.com/path?a=");
-    const url4 = new URL("https://example.com/path?a=");
-    expect(isUrlEqual(url3, url4)).toBe(true);
-  });
-  test("should handle URLs with userinfo", () => {
-    const url1 = new URL("https://user:pass@example.com/path");
-    const url2 = new URL("https://user:pass@example.com/path");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const url3 = new URL("https://user1:pass@example.com/path");
-    const url4 = new URL("https://user2:pass@example.com/path");
-    expect(isUrlEqual(url3, url4)).toBe(false);
-  });
-  test("should handle default ports correctly", () => {
-    const url1 = new URL("https://example.com/path");
-    const url2 = new URL("https://example.com:443/path");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const url3 = new URL("http://example.com/path");
-    const url4 = new URL("http://example.com:80/path");
-    expect(isUrlEqual(url3, url4)).toBe(true);
-  });
-  test("should handle trailing slashes in pathnames", () => {
-    const url1 = new URL("https://example.com/path/");
-    const url2 = new URL("https://example.com/path");
-    expect(isUrlEqual(url1, url2)).toBe(false);
-  });
-  test("should handle case sensitivity correctly", () => {
-    const url1 = new URL("https://Example.Com/path");
-    const url2 = new URL("https://example.com/path");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const url3 = new URL("https://example.com/Path");
-    const url4 = new URL("https://example.com/path");
-    expect(isUrlEqual(url3, url4)).toBe(false);
-    const url5 = new URL("https://example.com/path?Key=Value");
-    const url6 = new URL("https://example.com/path?key=value");
-    expect(isUrlEqual(url5, url6)).toBe(false);
-  });
-  test("should handle special characters in URLs", () => {
-    const url1 = new URL(
-      "https://example.com/path with spaces?q=hello world"
-    );
-    const url2 = new URL(
-      "https://example.com/path%20with%20spaces?q=hello%20world"
-    );
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const url3 = new URL("https://example.com/path?unicode=\u6D4B\u8BD5");
-    const url4 = new URL(
-      "https://example.com/path?unicode=%E6%B5%8B%E8%AF%95"
-    );
-    expect(isUrlEqual(url3, url4)).toBe(true);
-  });
-  test("should handle edge cases with empty values", () => {
-    const url1 = new URL("https://example.com/path?a=&b=test");
-    const url2 = new URL("https://example.com/path?b=test&a=");
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const url3 = new URL("https://example.com/path?flag");
-    const url4 = new URL("https://example.com/path?flag=");
-    expect(isUrlEqual(url3, url4)).toBe(true);
-  });
-  test("should handle performance with many parameters", () => {
-    const params1 = new URLSearchParams();
-    const params2 = new URLSearchParams();
-    for (let i = 0; i < 100; 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?".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();
-    expect(result).toBe(true);
-    expect(end - start).toBeLessThan(50);
-  });
-  test("should handle complex real-world scenarios", () => {
-    const baseUrl = "https://api.example.com/v1/users";
-    const url1 = new URL(
-      "".concat(baseUrl, "?page=1&limit=20&sort=name&filter=active&tag=user&tag=admin")
-    );
-    const url2 = new URL(
-      "".concat(baseUrl, "?limit=20&tag=user&page=1&tag=admin&filter=active&sort=name")
-    );
-    expect(isUrlEqual(url1, url2)).toBe(true);
-    const oauthUrl1 = new URL(
-      "https://oauth.example.com/authorize?client_id=123&redirect_uri=https%3A%2F%2Fapp.com%2Fcallback&scope=read%20write&state=random123"
-    );
-    const oauthUrl2 = new URL(
-      "https://oauth.example.com/authorize?scope=read%20write&state=random123&client_id=123&redirect_uri=https%3A%2F%2Fapp.com%2Fcallback"
-    );
-    expect(isUrlEqual(oauthUrl1, oauthUrl2)).toBe(true);
-  });
-});
-describe("isRouteMatched", () => {
-  const createOptions = () => {
-    return parsedOptions({
-      base: new URL("http://localhost:3000/"),
-      routes: [
-        { path: "/user/:id", component: "UserComponent" },
-        { path: "/settings", component: "SettingsComponent" }
-      ]
-    });
-  };
-  describe("route match type", () => {
-    test("should match routes with same config", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/456"
-      });
-      expect(isRouteMatched(route1, route2, "route")).toBe(true);
-    });
-    test("should not match routes with different config", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/settings"
-      });
-      expect(isRouteMatched(route1, route2, "route")).toBe(false);
-    });
-    test("should return false when second route is null", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      expect(isRouteMatched(route1, null, "route")).toBe(false);
-    });
-  });
-  describe("exact match type", () => {
-    test("should match routes with same fullPath", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123?tab=profile"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123?tab=profile"
-      });
-      expect(isRouteMatched(route1, route2, "exact")).toBe(true);
-    });
-    test("should not match routes with different fullPath", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123?tab=profile"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123?tab=settings"
-      });
-      expect(isRouteMatched(route1, route2, "exact")).toBe(false);
-    });
-    test("should not match routes with same path but different query", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123?tab=profile"
-      });
-      expect(isRouteMatched(route1, route2, "exact")).toBe(false);
-    });
-  });
-  describe("include match type", () => {
-    test("should match when route1 fullPath starts with route2 fullPath", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123/profile/settings"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      expect(isRouteMatched(route1, route2, "include")).toBe(true);
-    });
-    test("should match when fullPaths are exactly the same", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      expect(isRouteMatched(route1, route2, "include")).toBe(true);
-    });
-    test("should not match when route1 fullPath does not start with route2 fullPath", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/456"
-      });
-      expect(isRouteMatched(route1, route2, "include")).toBe(false);
-    });
-    test("should not match when route2 fullPath is longer", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      expect(isRouteMatched(route1, route2, "include")).toBe(false);
-    });
-  });
-  describe("edge cases", () => {
-    test("should handle root path correctly", () => {
-      const options = createOptions();
-      const route1 = new Route({ options });
-      const route2 = new Route({ options });
-      expect(isRouteMatched(route1, route2, "route")).toBe(true);
-      expect(isRouteMatched(route1, route2, "exact")).toBe(true);
-      expect(isRouteMatched(route1, route2, "include")).toBe(true);
-    });
-    test("should handle hash in fullPath", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123#section1"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123#section2"
-      });
-      expect(isRouteMatched(route1, route2, "route")).toBe(true);
-      expect(isRouteMatched(route1, route2, "exact")).toBe(false);
-    });
-    test("should return false for invalid match type", () => {
-      const options = createOptions();
-      const route1 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      const route2 = new Route({
-        options,
-        toType: RouteType.push,
-        toInput: "/user/123"
-      });
-      expect(isRouteMatched(route1, route2, "invalid")).toBe(false);
-    });
-  });
-});