@esmx/router 3.0.0-rc.18 → 3.0.0-rc.20

package/src/util.test.ts

@@ -0,0 +1,1262 @@
+import { describe, expect, test } from 'vitest';
+import { parsedOptions } from './options';
+import { Route } from './route';
+import type { RouterParsedOptions } from './types';
+import { RouteType } from './types';
+import {
+    isNonEmptyPlainObject,
+    isNotNullish,
+    isPlainObject,
+    isRouteMatched,
+    isUrlEqual,
+    isValidConfirmHookResult,
+    removeFromArray
+} from './util';
+
+const AsyncFunction = (async () => {}).constructor;
+
+// There are differences between literals and object wrappers:
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_primitives_and_string_objects
+
+describe('isNotNullish', () => {
+    test('should return true for non-nullish values', () => {
+        // Special values
+        expect(isNotNullish(null)).toBe(false);
+        expect(isNotNullish(void 0)).toBe(false);
+        // Numbers & bigint
+        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(123n)).toBe(true);
+        expect(isNotNullish(0n)).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);
+        // Strings
+        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);
+        // Boolean values
+        expect(isNotNullish(true)).toBe(true);
+        expect(isNotNullish(false)).toBe(true);
+        expect(isNotNullish(new Boolean(true))).toBe(true);
+        expect(isNotNullish(new Boolean(false))).toBe(true);
+        // Object
+        expect(isNotNullish({})).toBe(true);
+        expect(isNotNullish({ key: 'value' })).toBe(true);
+        expect(isNotNullish(new Object())).toBe(true);
+        expect(isNotNullish(Object.create(null))).toBe(true);
+        expect(isNotNullish(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
+        );
+        // Arrays & typed arrays related
+        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);
+        // Functions
+        expect(isNotNullish(() => {})).toBe(true);
+        expect(isNotNullish(async () => {})).toBe(true);
+        expect(isNotNullish(new Function('return 1;'))).toBe(true);
+        expect(isNotNullish(AsyncFunction('return 1;'))).toBe(true);
+        // Special objects
+        expect(isNotNullish(new Date())).toBe(true);
+        expect(isNotNullish(Symbol('test'))).toBe(true);
+        expect(isNotNullish(new Map())).toBe(true);
+        expect(isNotNullish(new Set())).toBe(true);
+        expect(isNotNullish(new WeakMap())).toBe(true);
+        expect(isNotNullish(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', () => {
+        // Various usages of Number constructor
+        expect(isNotNullish(Number())).toBe(true); // Number() returns 0
+        expect(isNotNullish(Number(undefined))).toBe(false); // Number(undefined) returns NaN
+        expect(isNotNullish(Number(null))).toBe(true); // Number(null) returns 0
+        expect(isNotNullish(Number(''))).toBe(true); // Number('') returns 0
+        expect(isNotNullish(Number('0'))).toBe(true); // Number('0') returns 0
+        expect(isNotNullish(Number('123'))).toBe(true); // Number('123') returns 123
+
+        // Various usages of new Number constructor
+        expect(isNotNullish(new Number())).toBe(true); // new Number() returns Number object
+        expect(isNotNullish(new Number(undefined))).toBe(false); // new Number(undefined) wraps NaN
+        expect(isNotNullish(new Number(null))).toBe(true); // new Number(null) wraps 0
+        expect(isNotNullish(new Number(''))).toBe(true); // new Number('') wraps 0
+        expect(isNotNullish(new Number('0'))).toBe(true); // new Number('0') wraps 0
+        expect(isNotNullish(new Number('123'))).toBe(true); // new Number('123') wraps 123
+    });
+
+    test('should handle various NaN cases', () => {
+        // Various situations that produce NaN
+        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);
+
+        // NaN wrapped in Number objects
+        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', () => {
+        // Objects created by custom constructors
+        class CustomClass {
+            constructor(public value: number) {}
+        }
+        expect(isNotNullish(new CustomClass(123))).toBe(true);
+
+        // Frozen and sealed objects
+        const frozenObj = Object.freeze({ a: 1 });
+        const sealedObj = Object.seal({ b: 2 });
+        expect(isNotNullish(frozenObj)).toBe(true);
+        expect(isNotNullish(sealedObj)).toBe(true);
+
+        // Objects created using defineProperty
+        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(Object.create(null))).toBe(true);
+        expect(isPlainObject(Object.create({}))).toBe(true);
+        expect(isPlainObject(Object.create(Object.prototype))).toBe(true);
+        expect(isPlainObject(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', () => {
+        // Special values
+        expect(isPlainObject(null)).toBe(false);
+        expect(isPlainObject(void 0)).toBe(false);
+        // Arrays & typed arrays related
+        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);
+        // Strings
+        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); // typeof (new String('')) === 'object'
+        expect(isPlainObject(new String('0'))).toBe(false);
+        expect(isPlainObject(new String('1'))).toBe(false);
+        expect(isPlainObject(new String('string'))).toBe(false);
+        // Boolean values
+        expect(isPlainObject(true)).toBe(false);
+        expect(isPlainObject(false)).toBe(false);
+        expect(isPlainObject(new Boolean(true))).toBe(false);
+        expect(isPlainObject(new Boolean(false))).toBe(false);
+        // Numbers & bigint
+        expect(isPlainObject(0)).toBe(false);
+        expect(isPlainObject(0n)).toBe(false);
+        expect(isPlainObject(123)).toBe(false);
+        expect(isPlainObject(123n)).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);
+        // Functions
+        expect(isPlainObject(() => {})).toBe(false);
+        expect(isPlainObject(async () => {})).toBe(false);
+        expect(isPlainObject(new Function('return 1;'))).toBe(false);
+        expect(isPlainObject(AsyncFunction('return 1;'))).toBe(false);
+        // Special objects
+        expect(isPlainObject(new Date())).toBe(false);
+        expect(isPlainObject(Symbol('test'))).toBe(false);
+        expect(isPlainObject(new Map())).toBe(false);
+        expect(isPlainObject(new Set())).toBe(false);
+        expect(isPlainObject(new WeakMap())).toBe(false);
+        expect(isPlainObject(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); // Equivalent to new Number(42)
+        expect(isPlainObject(Object('str'))).toBe(false); // Equivalent to new String('str')
+        expect(isPlainObject(Object(true))).toBe(false); // Equivalent to new Boolean(true)
+        expect(isPlainObject(Object(Symbol('sym')))).toBe(false); // Symbol wrapper object
+    });
+});
+
+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() as any;
+        obj.prop = 'value';
+        expect(isNonEmptyPlainObject(obj)).toBe(true);
+
+        const objWithProto = Object.create({ parent: 'value' });
+        objWithProto.own = 'property';
+        expect(isNonEmptyPlainObject(objWithProto)).toBe(true);
+
+        class TestClass {}
+        const instance = new TestClass() as any;
+        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(Object.create(null))).toBe(false);
+        expect(isNonEmptyPlainObject(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);
+
+        // Objects with Symbol properties should be considered empty
+        expect(isNonEmptyPlainObject({ [Symbol.toStringTag]: 'Tag' })).toBe(
+            false
+        );
+        expect(isNonEmptyPlainObject({ [Symbol('key')]: 'value' })).toBe(false);
+    });
+
+    test('should return false for non-objects', () => {
+        // Special values
+        expect(isNonEmptyPlainObject(null)).toBe(false);
+        expect(isNonEmptyPlainObject(void 0)).toBe(false);
+
+        // Primitive types
+        expect(isNonEmptyPlainObject('')).toBe(false);
+        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(true)).toBe(false);
+        expect(isNonEmptyPlainObject(false)).toBe(false);
+        expect(isNonEmptyPlainObject(Symbol('test'))).toBe(false);
+
+        // Arrays
+        expect(isNonEmptyPlainObject([])).toBe(false);
+        expect(isNonEmptyPlainObject(['a', 'b'])).toBe(false);
+
+        // Functions
+        expect(isNonEmptyPlainObject(() => {})).toBe(false);
+        expect(isNonEmptyPlainObject(async () => {})).toBe(false);
+
+        // Special object types
+        expect(isNonEmptyPlainObject(new Date())).toBe(false);
+        expect(isNonEmptyPlainObject(new Map())).toBe(false);
+        expect(isNonEmptyPlainObject(new Set())).toBe(false);
+        expect(isNonEmptyPlainObject(/test/)).toBe(false);
+        expect(isNonEmptyPlainObject(new Error('test'))).toBe(false);
+        expect(isNonEmptyPlainObject(Promise.resolve())).toBe(false);
+
+        // Wrapper objects
+        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', () => {
+        // Objects with only inherited properties, no own 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', () => {
+        // Objects with non-enumerable properties
+        const objWithNonEnum = {};
+        Object.defineProperty(objWithNonEnum, 'nonEnum', {
+            value: 'hidden',
+            enumerable: false
+        });
+        expect(isNonEmptyPlainObject(objWithNonEnum)).toBe(false); // Object.keys will not include non-enumerable properties
+
+        Object.defineProperty(objWithNonEnum, 'visible', {
+            value: 'visible',
+            enumerable: true
+        });
+        expect(isNonEmptyPlainObject(objWithNonEnum)).toBe(true); // Now has enumerable properties
+
+        // Frozen objects
+        const frozenObj = Object.freeze({ prop: 'value' });
+        expect(isNonEmptyPlainObject(frozenObj)).toBe(true);
+
+        // Sealed objects
+        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]);
+
+        // `new Number(2)` is not the same as `2`
+        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', () => {
+        // Empty array
+        const emptyArr: any[] = [];
+        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]);
+
+        // Contains undefined and null
+        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', () => {
+        // Sparse array - array with empty slots
+        // biome-ignore lint/suspicious/noSparseArray: skip
+        const sparseArr = [1, , 3, , 5];
+        removeFromArray(sparseArr, void 0);
+        // Length should not change, empty slots cannot be treated as undefined placeholders
+        expect(sparseArr).toHaveLength(5);
+        // biome-ignore lint/suspicious/noSparseArray: skip
+        expect(sparseArr).toEqual([1, , 3, , 5]);
+    });
+
+    test('should handle arrays with complex objects', () => {
+        // Complex object array
+        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' } });
+
+        // Remove non-existing similar object
+        removeFromArray(complexArr, { id: 1, nested: { value: 'a' } });
+        expect(complexArr).toHaveLength(2); // No change
+    });
+
+    test('should handle arrays with different primitive types', () => {
+        let mixedArr: any[] = [1, '1', true, 1n, Symbol('test')];
+
+        // Remove number 1
+        removeFromArray(mixedArr, 1);
+        expect(mixedArr).toEqual(['1', true, 1n, expect.any(Symbol)]);
+
+        mixedArr = [1, '1', true, 1n, Symbol('test')];
+
+        // Remove string '1'
+        removeFromArray(mixedArr, '1');
+        expect(mixedArr).toEqual([1, true, 1n, expect.any(Symbol)]);
+
+        const mixedArray: any[] = [
+            'string',
+            42,
+            true,
+            null,
+            undefined,
+            { obj: 'value' },
+            [1, 2, 3],
+            Symbol('test'),
+            () => 'fn',
+            new Date(),
+            /regex/,
+            new Map(),
+            new Set()
+        ];
+
+        const originalLength = mixedArray.length;
+
+        removeFromArray(mixedArray, 'nonexistent');
+        expect(mixedArray).toHaveLength(originalLength);
+
+        // Delete existing element
+        removeFromArray(mixedArray, 42);
+        expect(mixedArray).toHaveLength(originalLength - 1);
+        expect(mixedArray.includes(42)).toBe(false);
+    });
+
+    test('should preserve array structure', () => {
+        const arr: any[] = [1, 2, 3];
+        (arr as any).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 as any).customProperty).toBe('test');
+    });
+
+    test('should handle array with getter/setter elements', () => {
+        const arr: any[] = [1, 2, 3];
+
+        // Add element with getter/setter
+        Object.defineProperty(arr, '1', {
+            get() {
+                return 'getter';
+            },
+            set() {
+                /* setter */
+            },
+            enumerable: true
+        });
+
+        removeFromArray(arr, 'getter');
+        expect(arr).toHaveLength(2);
+        expect(arr[0]).toBe(1);
+        expect(arr[1]).toBe('getter'); // getter still exists
+    });
+
+    test('should handle strict equality in removeFromArray', () => {
+        const obj1 = { id: 1 };
+        const obj2 = { id: 1 }; // Same content but different reference
+        const arr = [obj1, obj2];
+
+        removeFromArray(arr, obj1);
+        expect(arr).toHaveLength(1);
+        expect(arr[0]).toBe(obj2);
+
+        // Objects with same content but different reference will not be deleted
+        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);
+        // Does not accept new Boolean() wrapped boolean values
+        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);
+        // Does not accept new String() wrapped strings
+        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(Object.create(null))).toBe(true);
+        expect(isValidConfirmHookResult(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', () => {
+        // Special values
+        expect(isValidConfirmHookResult(null)).toBe(false);
+        expect(isValidConfirmHookResult(void 0)).toBe(false);
+        // Numbers & bigint
+        expect(isValidConfirmHookResult(123)).toBe(false);
+        expect(isValidConfirmHookResult(0)).toBe(false);
+        expect(isValidConfirmHookResult(123n)).toBe(false);
+        expect(isValidConfirmHookResult(0n)).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);
+        // Arrays
+        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
+        );
+        // Special objects
+        expect(isValidConfirmHookResult(new Date())).toBe(false);
+        expect(isValidConfirmHookResult(Symbol('test'))).toBe(false);
+        expect(isValidConfirmHookResult(new Map())).toBe(false);
+        expect(isValidConfirmHookResult(new Set())).toBe(false);
+        expect(isValidConfirmHookResult(new WeakMap())).toBe(false);
+        expect(isValidConfirmHookResult(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', () => {
+        // Promise related - should return false
+        expect(isValidConfirmHookResult(Promise.resolve(true))).toBe(false);
+
+        // Handle rejected promise to avoid unhandled rejection
+        const rejectedPromise = Promise.reject(false);
+        rejectedPromise.catch(() => {}); // Prevent unhandled rejection
+        expect(isValidConfirmHookResult(rejectedPromise)).toBe(false);
+
+        // Async functions return Promise, but the function itself is valid
+        const asyncFn = async () => true;
+        expect(isValidConfirmHookResult(asyncFn)).toBe(true);
+
+        // Arrow functions and regular functions
+        expect(isValidConfirmHookResult((x: number) => x > 0)).toBe(true);
+        expect(isValidConfirmHookResult((x: number) => x > 0)).toBe(true);
+
+        // Generator function
+        expect(
+            isValidConfirmHookResult(function* () {
+                yield 1;
+            })
+        ).toBe(true);
+
+        // Class constructor
+        class TestClass {}
+        expect(isValidConfirmHookResult(TestClass)).toBe(true);
+    });
+
+    test('should handle objects with Symbol properties', () => {
+        // Objects containing Symbol properties
+        const symKey = Symbol('key');
+        const objWithSymbol = { [symKey]: 'value', regular: 'prop' };
+        expect(isValidConfirmHookResult(objWithSymbol)).toBe(true);
+
+        // Symbol.toStringTag object
+        const objWithToStringTag = { [Symbol.toStringTag]: 'CustomObject' };
+        expect(isValidConfirmHookResult(objWithToStringTag)).toBe(true);
+    });
+
+    test('should handle frozen and sealed objects', () => {
+        // Frozen objects
+        const frozenObj = Object.freeze({ frozen: true });
+        expect(isValidConfirmHookResult(frozenObj)).toBe(true);
+
+        // Sealed objects
+        const sealedObj = Object.seal({ sealed: true });
+        expect(isValidConfirmHookResult(sealedObj)).toBe(true);
+
+        // Non-extensible object
+        const nonExtensibleObj = Object.preventExtensions({
+            nonExtensible: true
+        });
+        expect(isValidConfirmHookResult(nonExtensibleObj)).toBe(true);
+    });
+
+    test('should handle function edge cases', () => {
+        // Bound function
+        const originalFn = function (this: any, x: number) {
+            return this.value + x;
+        };
+        const boundFn = originalFn.bind({ value: 10 });
+        expect(isValidConfirmHookResult(boundFn)).toBe(true);
+
+        // Function call and apply methods
+        expect(isValidConfirmHookResult(originalFn.call)).toBe(true);
+        expect(isValidConfirmHookResult(originalFn.apply)).toBe(true);
+
+        // Built-in functions
+        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 instance - according to actual implementation, class instances are identified as objects through toString check
+        class TestClass {
+            constructor(public value: number) {}
+        }
+        expect(isValidConfirmHookResult(new TestClass(42))).toBe(true); // Class instance passes isPlainObject check
+
+        // Inherited class instance
+        class ChildClass extends TestClass {}
+        expect(isValidConfirmHookResult(new ChildClass(42))).toBe(true); // Also identified as object
+
+        // Error instances
+        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: 10000 }, (_, i) => i);
+        const target = 5000;
+
+        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); // Should complete within 100ms
+    });
+
+    test('should handle multiple rapid calls to utility functions', () => {
+        const iterations = 1000;
+        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); // Should complete within 50ms
+    });
+
+    test('should handle rapid array modifications', () => {
+        const arr = [1, 2, 3, 4, 5];
+        const start = performance.now();
+
+        // Perform multiple delete operations quickly
+        removeFromArray(arr, 3);
+        removeFromArray(arr, 1);
+        removeFromArray(arr, 5);
+        removeFromArray(arr, 99); // Non-existing element
+
+        const end = performance.now();
+        expect(arr).toEqual([2, 4]);
+        expect(end - start).toBeLessThan(10); // Should be very fast
+    });
+});
+
+// Error handling and boundary tests
+describe('Error Handling Tests', () => {
+    test('should handle circular references in objects', () => {
+        const circularObj: any = { name: 'circular' };
+        circularObj.self = circularObj;
+
+        // These functions should handle circular references without crashing
+        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');
+
+        // Test comparison with null
+        expect(isUrlEqual(url1, null)).toBe(false);
+
+        // Test comparison with undefined (optional parameter not provided)
+        expect(isUrlEqual(url1, undefined)).toBe(false);
+
+        // Test omitting second parameter (automatically undefined)
+        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, undefined)).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); // Both hashes are empty strings, should be equal
+    });
+
+    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');
+        // url1's query `a` should be 2, but url2's query `a` should be 1, so they should not be equal
+        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'
+        );
+        // query `tag` one is green and one is red, so they are different
+        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', () => {
+        // Hostname should be case-insensitive (handled by URL constructor)
+        const url1 = new URL('https://Example.Com/path');
+        const url2 = new URL('https://example.com/path');
+        expect(isUrlEqual(url1, url2)).toBe(true);
+
+        // Paths are case-sensitive
+        const url3 = new URL('https://example.com/Path');
+        const url4 = new URL('https://example.com/path');
+        expect(isUrlEqual(url3, url4)).toBe(false);
+
+        // Query parameters are case-sensitive
+        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=测试');
+        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', () => {
+        // Empty query parameter 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);
+
+        // Parameters with only keys but no values
+        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', () => {
+        // Build URL with many parameters
+        const params1 = new URLSearchParams();
+        const params2 = new URLSearchParams();
+
+        // Add 100 parameters in different order
+        for (let i = 0; i < 100; i++) {
+            params1.append(`param${i}`, `value${i}`);
+            params2.append(`param${99 - i}`, `value${99 - i}`);
+        }
+
+        const url1 = new URL(`https://example.com/path?${params1}`);
+        const url2 = new URL(`https://example.com/path?${params2}`);
+
+        const start = performance.now();
+        const result = isUrlEqual(url1, url2);
+        const end = performance.now();
+
+        expect(result).toBe(true);
+        expect(end - start).toBeLessThan(50); // Should complete within 50ms
+    });
+
+    test('should handle complex real-world scenarios', () => {
+        const baseUrl = 'https://api.example.com/v1/users';
+
+        // Pagination and filter parameters
+        const url1 = new URL(
+            `${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`
+        );
+        expect(isUrlEqual(url1, url2)).toBe(true);
+
+        // OAuth parameters
+        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 = (): RouterParsedOptions => {
+        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'
+            });
+
+            // @ts-expect-error - testing invalid match type
+            expect(isRouteMatched(route1, route2, 'invalid')).toBe(false);
+        });
+    });
+});