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

package/dist/matcher.test.mjs

@@ -1,1492 +0,0 @@
-import { assert, describe, test } from "vitest";
-import { createMatcher, joinPathname } from "./matcher.mjs";
-const BASE_URL = new URL("https://www.esmx.dev");
-describe("joinPathname", () => {
-  const testCases = [
-    {
-      description: "Basic path joining",
-      cases: [
-        { path: "test", expected: "/test" },
-        { path: "/test", expected: "/test" },
-        { path: "test/", expected: "/test" },
-        { path: "/test/", expected: "/test" }
-      ]
-    },
-    {
-      description: "Path joining with a base",
-      cases: [
-        { path: "test", base: "/api", expected: "/api/test" },
-        { path: "/test", base: "/api", expected: "/api/test" },
-        { path: "test", base: "api", expected: "/api/test" },
-        { path: "/test", base: "api", expected: "/api/test" }
-      ]
-    },
-    {
-      description: "Multi-level path joining",
-      cases: [
-        { path: "test/path", expected: "/test/path" },
-        { path: "/test/path", expected: "/test/path" },
-        { path: "test/path/", expected: "/test/path" },
-        { path: "/test/path/", expected: "/test/path" }
-      ]
-    },
-    {
-      description: "Multi-level path joining with a base",
-      cases: [
-        { path: "test/path", base: "/api", expected: "/api/test/path" },
-        { path: "/test/path", base: "/api", expected: "/api/test/path" },
-        { path: "test/path", base: "api", expected: "/api/test/path" },
-        { path: "/test/path", base: "api", expected: "/api/test/path" }
-      ]
-    },
-    {
-      description: "Handling duplicate slashes",
-      cases: [
-        { path: "//test", expected: "/test" },
-        { path: "test//path", expected: "/test/path" },
-        { path: "//test//path//", expected: "/test/path" },
-        { path: "test//path", base: "/api//", expected: "/api/test/path" }
-      ]
-    },
-    {
-      description: "Handling empty values",
-      cases: [
-        { path: "", expected: "/" },
-        { path: "", base: "", expected: "/" },
-        { path: "test", base: "", expected: "/test" },
-        { path: "", base: "api", expected: "/api" }
-      ]
-    },
-    {
-      description: "Paths with special characters",
-      cases: [
-        { path: "test-path", expected: "/test-path" },
-        { path: "test_path", expected: "/test_path" },
-        { path: "test.path", expected: "/test.path" },
-        { path: "test:path", expected: "/test:path" },
-        { path: "test@path", expected: "/test@path" }
-      ]
-    },
-    {
-      description: "Support for Chinese characters in paths",
-      cases: [
-        { path: "\u6D4B\u8BD5", expected: "/\u6D4B\u8BD5" },
-        { path: "\u6D4B\u8BD5/\u8DEF\u5F84", expected: "/\u6D4B\u8BD5/\u8DEF\u5F84" },
-        { path: "\u6D4B\u8BD5", base: "/api", expected: "/api/\u6D4B\u8BD5" }
-      ]
-    }
-  ];
-  const edgeCases = [
-    {
-      description: "Paths with only slashes or empty strings",
-      cases: [
-        { path: "", expected: "/" },
-        { path: "/", expected: "/" },
-        { path: "///", expected: "/" },
-        { path: "/", base: "/", expected: "/" },
-        { path: "/", base: "//", expected: "/" },
-        { path: "//", base: "/", expected: "/" },
-        { path: "//", base: "//", expected: "/" }
-      ]
-    },
-    {
-      description: "Extremely long path joining",
-      cases: () => {
-        const longSegment = "very-long-segment-name-that-could-cause-issues";
-        const base = Array(10).fill(longSegment).join("/");
-        const path = Array(10).fill(longSegment).join("/");
-        const expected = "/".concat(base, "/").concat(path);
-        return [{ path, base, expected }];
-      }
-    },
-    {
-      description: "Joining paths with special characters",
-      cases: [
-        { path: "\u6D4B\u8BD5\u8DEF\u5F84", base: "\u57FA\u7840", expected: "/\u57FA\u7840/\u6D4B\u8BD5\u8DEF\u5F84" },
-        { path: "path with spaces", base: "base", expected: "/base/path with spaces" },
-        { path: "path-with-dashes", base: "base_with_underscores", expected: "/base_with_underscores/path-with-dashes" }
-      ]
-    },
-    {
-      description: "Handling URL-encoded characters",
-      cases: [
-        { path: "hello%20world", base: "api", expected: "/api/hello%20world" },
-        { path: "user%2Fprofile", base: "v1", expected: "/v1/user%2Fprofile" }
-      ]
-    },
-    {
-      description: "Handling dot segments in paths",
-      cases: [
-        { path: ".", expected: "/." },
-        { path: "..", expected: "/.." },
-        { path: "./relative", base: "base", expected: "/base/./relative" },
-        { path: "../parent", base: "base", expected: "/base/../parent" }
-      ]
-    },
-    {
-      description: "Query parameters and hash do not affect joining",
-      cases: [
-        { path: "path?query=1", base: "base", expected: "/base/path?query=1" },
-        { path: "path#hash", base: "base", expected: "/base/path#hash" },
-        { path: "path?q=1#hash", base: "base", expected: "/base/path?q=1#hash" }
-      ]
-    },
-    {
-      description: "Paths starting with a colon (route parameters)",
-      cases: [
-        { path: ":id", base: "users", expected: "/users/:id" },
-        { path: ":userId/profile", base: "api", expected: "/api/:userId/profile" }
-      ]
-    },
-    {
-      description: "Paths with wildcard asterisks",
-      cases: [
-        { path: ":rest*", base: "files", expected: "/files/:rest*" },
-        { path: ":rest*", base: "assets", expected: "/assets/:rest*" },
-        { path: "images/:rest*", base: "static", expected: "/static/images/:rest*" },
-        { path: "/*splat", base: "base", expected: "/base/*splat" }
-      ]
-    },
-    {
-      description: "Optional paths",
-      cases: [
-        { path: ":id?", base: "posts", expected: "/posts/:id?" },
-        { path: "comments/:commentId?", base: "articles", expected: "/articles/comments/:commentId?" },
-        { path: "/users{/:id}/delete?", base: "base", expected: "/base/users{/:id}/delete?" }
-      ]
-    },
-    {
-      description: "Combination of numbers and special symbols",
-      cases: [
-        { path: "v1.2.3", base: "api", expected: "/api/v1.2.3" },
-        { path: "user@domain", base: "profile", expected: "/profile/user@domain" },
-        { path: "item_123", base: "products", expected: "/products/item_123" }
-      ]
-    },
-    {
-      description: "Whitespace character handling",
-      cases: [
-        { path: "  path  ", base: "  base  ", expected: "/  base  /  path  " },
-        { path: "	path	", base: "	base	", expected: "/	base	/	path	" }
-      ]
-    },
-    {
-      description: "Boolean and numeric paths (boundary test)",
-      cases: [
-        { path: "true", base: "false", expected: "/false/true" },
-        { path: "0", base: "1", expected: "/1/0" },
-        { path: "NaN", base: "undefined", expected: "/undefined/NaN" }
-      ]
-    },
-    {
-      description: "Extreme cases of path normalization",
-      cases: [
-        // Test normalization of multiple slashes
-        { path: "///path///", base: "///base///", expected: "/base/path" },
-        { path: "path////with////slashes", base: "base////with////slashes", expected: "/base/with/slashes/path/with/slashes" }
-      ]
-    },
-    {
-      description: "Handling of non-ASCII character paths",
-      cases: [
-        { path: "\u043F\u0443\u0442\u044C", base: "\u0431\u0430\u0437\u0430", expected: "/\u0431\u0430\u0437\u0430/\u043F\u0443\u0442\u044C" },
-        // Russian
-        { path: "\u30D1\u30B9", base: "\u30D9\u30FC\u30B9", expected: "/\u30D9\u30FC\u30B9/\u30D1\u30B9" },
-        // Japanese
-        { path: "\uACBD\uB85C", base: "\uAE30\uBCF8", expected: "/\uAE30\uBCF8/\uACBD\uB85C" },
-        // Korean
-        { path: "\u0645\u0633\u0627\u0631", base: "\u0642\u0627\u0639\u062F\u0629", expected: "/\u0642\u0627\u0639\u062F\u0629/\u0645\u0633\u0627\u0631" }
-        // Arabic
-      ]
-    },
-    {
-      description: "Handling of special symbols and punctuation",
-      cases: [
-        { path: "path!@#$%^&\\*()", base: "base!@#$%^&\\*()", expected: "/base!@#$%^&\\*()/path!@#$%^&\\*()" },
-        { path: "path\\[]{};:\"'<>\\?", base: "base\\[]{};:\"'<>\\?", expected: "/base\\[]{};:\"'<>\\?/path\\[]{};:\"'<>\\?" },
-        { path: "path\\backslash", base: "base\\backslash\\", expected: "/base\\backslash\\/path\\backslash" }
-      ]
-    },
-    {
-      description: "Paths with combinations of numbers and symbols",
-      cases: [
-        { path: "123.456.789", base: "v1.0.0", expected: "/v1.0.0/123.456.789" },
-        { path: "item-123_abc", base: "category-456_def", expected: "/category-456_def/item-123_abc" },
-        { path: "2023-12-31", base: "2024-01-01", expected: "/2024-01-01/2023-12-31" }
-      ]
-    },
-    {
-      description: "Various forms of whitespace characters",
-      cases: [
-        { path: " ", base: " ", expected: "/ / " },
-        { path: "\n", base: "	", expected: "/	/\n" },
-        { path: "\r\n", base: "	\r", expected: "/	\r/\r\n" },
-        // Test carriage return and line feed
-        { path: "\xA0", base: "\u2000", expected: "/\u2000/\xA0" }
-        // Non-breaking space and em space
-      ]
-    },
-    {
-      description: "Handling of very long paths",
-      cases: () => {
-        const veryLongSegment = "a".repeat(1e3);
-        const path = veryLongSegment + "/segment";
-        const base = "base/" + veryLongSegment;
-        const expected = "/" + base + "/" + path;
-        return [{ path, base, expected }];
-      }
-    },
-    {
-      description: "Boundary cases for path separators",
-      cases: [
-        { path: "/", base: "/", expected: "/" },
-        { path: "//", base: "//", expected: "/" },
-        { path: "///", base: "///", expected: "/" },
-        { path: "path/", base: "/base", expected: "/base/path" },
-        { path: "/path/", base: "/base/", expected: "/base/path" }
-      ]
-    },
-    {
-      description: "URL-encoded path segments",
-      cases: [
-        { path: "%20space%20", base: "%20base%20", expected: "/%20base%20/%20space%20" },
-        { path: "%2F%2F", base: "%2F", expected: "/%2F/%2F%2F" },
-        { path: "path%3Fquery%3D1", base: "base%23hash", expected: "/base%23hash/path%3Fquery%3D1" }
-      ]
-    },
-    {
-      description: "Numeric type paths (type boundary)",
-      cases: [
-        { path: "123", base: "456", expected: "/456/123" },
-        { path: "0", expected: "/0" },
-        { path: "", base: "0", expected: "/0" }
-      ]
-    },
-    {
-      description: "Complex cases with dot notation in paths",
-      cases: [
-        { path: "../../../path", base: "../../base", expected: "/../../base/../../../path" },
-        { path: "./././path", base: "./././base", expected: "/./././base/./././path" },
-        { path: "path/./file", base: "base/../dir", expected: "/base/../dir/path/./file" }
-      ]
-    },
-    {
-      description: "Paths with mixed character sets",
-      cases: [
-        { path: "\u4E2D\u6587/english/\u0440\u0443\u0441\u0441\u043A\u0438\u0439", base: "\u65E5\u672C\u8A9E/\u0627\u0644\u0639\u0631\u0628\u064A\u0629", expected: "/\u65E5\u672C\u8A9E/\u0627\u0644\u0639\u0631\u0628\u064A\u0629/\u4E2D\u6587/english/\u0440\u0443\u0441\u0441\u043A\u0438\u0439" },
-        { path: "\u6D4B\u8BD5-test-\u0442\u0435\u0441\u0442", base: "\u57FA\u7840-base-\u0431\u0430\u0437\u0430", expected: "/\u57FA\u7840-base-\u0431\u0430\u0437\u0430/\u6D4B\u8BD5-test-\u0442\u0435\u0441\u0442" }
-      ]
-    },
-    {
-      description: "Handling of control characters",
-      cases: [
-        // Test control characters (though uncommon in actual URLs)
-        { path: "
", base: "", expected: "//
" },
-        { path: "path\x7F", base: "base\x7F", expected: "/base\x7F/path\x7F" }
-      ]
-    },
-    {
-      description: "Various characters at the end of a path",
-      cases: [
-        { path: "path.", base: "base.", expected: "/base./path." },
-        { path: "path-", base: "base-", expected: "/base-/path-" },
-        { path: "path_", base: "base_", expected: "/base_/path_" },
-        { path: "path~", base: "base~", expected: "/base~/path~" }
-      ]
-    }
-  ];
-  const runTests = (testCases2) => testCases2.forEach(({ description, cases }) => {
-    if (typeof cases === "function") {
-      cases = cases();
-    }
-    test(description, () => {
-      for (const { path, base, expected } of cases) {
-        assert.equal(joinPathname(path, base), expected);
-      }
-    });
-  });
-  runTests(testCases);
-  describe("Edge Cases", () => runTests(edgeCases));
-});
-describe("createMatcher", () => {
-  test("Basic route matching", () => {
-    const matcher = createMatcher([
-      { path: "/news" },
-      { path: "/news/:id" }
-    ]);
-    const result = matcher(new URL("/news/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/news/:id");
-    assert.equal(result.params.id, "123");
-  });
-  test("Exact route matching priority", () => {
-    const matcher = createMatcher([
-      { path: "/news/:id" },
-      { path: "/news" }
-    ]);
-    const result = matcher(new URL("/news", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/news");
-    assert.deepEqual(result.params, {});
-  });
-  test("Nested route matching", () => {
-    const matcher = createMatcher([
-      {
-        path: "/news",
-        children: [{ path: ":id" }]
-      }
-    ]);
-    const result = matcher(new URL("/news/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 2);
-    assert.equal(result.matches[0].path, "/news");
-    assert.equal(result.matches[1].path, ":id");
-    assert.equal(result.params.id, "123");
-  });
-  test("Deeply nested route matching", () => {
-    const matcher = createMatcher([
-      {
-        path: "/user",
-        children: [
-          {
-            path: ":userId",
-            children: [{ path: "profile" }, { path: "settings" }]
-          }
-        ]
-      }
-    ]);
-    const result = matcher(
-      new URL("/user/123/profile", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 3);
-    assert.equal(result.matches[0].path, "/user");
-    assert.equal(result.matches[1].path, ":userId");
-    assert.equal(result.matches[2].path, "profile");
-    assert.equal(result.params.userId, "123");
-  });
-  test("Multiple parameter route matching", () => {
-    const matcher = createMatcher([{ path: "/user/:userId/post/:postId" }]);
-    const result = matcher(
-      new URL("/user/123/post/456", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/user/:userId/post/:postId");
-    assert.equal(result.params.userId, "123");
-    assert.equal(result.params.postId, "456");
-  });
-  test("Optional parameter route matching", () => {
-    const matcher = createMatcher([{ path: "/posts/:id?" }]);
-    const resultWithParam = matcher(
-      new URL("/posts/123", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(resultWithParam.matches.length, 1);
-    assert.equal(resultWithParam.params.id, "123");
-    const resultWithoutParam = matcher(
-      new URL("/posts", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(resultWithoutParam.matches.length, 1);
-    assert.equal(resultWithoutParam.params.id, void 0);
-  });
-  test("Numeric parameter route matching", () => {
-    const matcher = createMatcher([{ path: "/posts/:id(\\d+)" }]);
-    const resultWithParam = matcher(
-      new URL("/posts/123", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(resultWithParam.matches.length, 1);
-    assert.equal(resultWithParam.params.id, "123");
-    const resultWithoutParam = matcher(
-      new URL("/posts/123a", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(resultWithoutParam.matches.length, 0);
-    const resultWithNaN = matcher(
-      new URL("/posts/NaN", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(resultWithNaN.matches.length, 0);
-  });
-  test("Wildcard route matching", () => {
-    const matcher = createMatcher([{ path: "/files/:rest*" }]);
-    const result = matcher(
-      new URL("/files/documents/readme.txt", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/files/:rest*");
-    assert.deepEqual(result.params.rest, ["documents", "readme.txt"]);
-  });
-  test("RegExp parameter matching", () => {
-    const matcher = createMatcher([{ path: "/api/v:version(\\d+)" }]);
-    const result = matcher(new URL("/api/v1", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.version, "1");
-  });
-  test("No matching route", () => {
-    const matcher = createMatcher([{ path: "/news" }]);
-    const result = matcher(new URL("/blog", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-    assert.deepEqual(result.params, {});
-  });
-  test("Empty route configuration", () => {
-    const matcher = createMatcher([]);
-    const result = matcher(new URL("/any", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-    assert.deepEqual(result.params, {});
-  });
-  test("Route meta information passing", () => {
-    var _a, _b;
-    const matcher = createMatcher([
-      {
-        path: "/protected",
-        meta: { requiresAuth: true }
-      }
-    ]);
-    const result = matcher(new URL("/protected", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal((_b = (_a = result.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.requiresAuth, true);
-  });
-  test("Complex nested routes with parameters", () => {
-    var _a, _b;
-    const matcher = createMatcher([
-      {
-        path: "/admin",
-        meta: { role: "admin" },
-        children: [
-          {
-            path: "users",
-            children: [
-              {
-                path: ":userId",
-                children: [{ path: "edit" }]
-              }
-            ]
-          }
-        ]
-      }
-    ]);
-    const result = matcher(
-      new URL("/admin/users/123/edit", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 4);
-    assert.equal(result.matches[0].path, "/admin");
-    assert.equal(result.matches[1].path, "users");
-    assert.equal(result.matches[2].path, ":userId");
-    assert.equal(result.matches[3].path, "edit");
-    assert.equal(result.params.userId, "123");
-    assert.equal((_b = (_a = result.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.role, "admin");
-  });
-  test("baseURL with directory", () => {
-    const matcher = createMatcher([{ path: "/api" }]);
-    const customBaseURL = new URL("https://www.esmx.dev/app/");
-    const result = matcher(
-      new URL("https://www.esmx.dev/app/api"),
-      customBaseURL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/api");
-  });
-  test("URL-encoded parameter handling", () => {
-    const matcher = createMatcher([{ path: "/search/:query" }]);
-    const result = matcher(
-      new URL("/search/hello world", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.query, "hello%20world");
-  });
-  test("Chinese path parameters", () => {
-    const matcher = createMatcher([
-      { path: "/".concat(encodeURIComponent("\u5206\u7C7B"), "/:name") }
-    ]);
-    const result = matcher(new URL("/\u5206\u7C7B/\u6280\u672F", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.name, encodeURIComponent("\u6280\u672F"));
-  });
-  test("Duplicate parameter name handling", () => {
-    const matcher = createMatcher([
-      {
-        path: "/parent/:id",
-        children: [{ path: "child/:childId" }]
-      }
-    ]);
-    const result = matcher(
-      new URL("/parent/123/child/456", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 2);
-    assert.equal(result.params.id, "123");
-    assert.equal(result.params.childId, "456");
-  });
-  test.todo("Route matching order consistency", () => {
-    var _a, _b, _c, _d;
-    const matcher = createMatcher([
-      {
-        path: "/a/:id",
-        meta: { order: 1 }
-      },
-      {
-        path: "/a/special",
-        meta: { order: 2 }
-      }
-    ]);
-    const result1 = matcher(new URL("/a/123", BASE_URL), BASE_URL);
-    assert.equal(result1.matches.length, 1);
-    assert.equal((_b = (_a = result1.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.order, 1);
-    const result2 = matcher(new URL("/a/special", BASE_URL), BASE_URL);
-    assert.equal(result2.matches.length, 1);
-    assert.equal((_d = (_c = result2.matches[0]) == null ? void 0 : _c.meta) == null ? void 0 : _d.order, 2);
-  });
-  test("Special characters in path handling", () => {
-    const routes = [
-      { path: "/test-path" },
-      { path: "/test_path" },
-      { path: "/test.path" }
-    ];
-    const matcher = createMatcher(routes);
-    for (const { path } of routes) {
-      const result = matcher(new URL(path, BASE_URL), BASE_URL);
-      assert.equal(result.matches.length, 1);
-      assert.equal(result.matches[0].path, path);
-    }
-  });
-  test("Empty string path handling", () => {
-    const matcher = createMatcher([
-      {
-        path: "",
-        children: [{ path: "child" }]
-      }
-    ]);
-    const result = matcher(new URL("/child", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 2);
-    assert.equal(result.matches[0].path, "");
-    assert.equal(result.matches[1].path, "child");
-  });
-  test.todo("Route matching performance verification", () => {
-    const routes = Array.from({ length: 1e3 }, (_, i) => ({
-      path: "/route".concat(i, "/:id")
-    }));
-    routes.push({ path: "/target/:id" });
-    const matcher = createMatcher(routes);
-    const startTime = performance.now();
-    const result = matcher(new URL("/target/123", BASE_URL), BASE_URL);
-    const endTime = performance.now();
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.id, "123");
-    assert.isTrue(endTime - startTime < 10);
-  });
-  test("Edge case: extremely long path", () => {
-    const longPath = "/very/long/path/with/many/segments/that/goes/on/and/on/and/on";
-    const matcher = createMatcher([{ path: longPath }]);
-    const result = matcher(new URL(longPath, BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, longPath);
-  });
-  test("Edge case: large number of parameters", () => {
-    const matcher = createMatcher([
-      { path: "/:a/:b/:c/:d/:e/:f/:g/:h/:i/:j" }
-    ]);
-    const result = matcher(
-      new URL("/1/2/3/4/5/6/7/8/9/10", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.a, "1");
-    assert.equal(result.params.j, "10");
-    assert.equal(Object.keys(result.params).length, 10);
-  });
-  test("Path rewriting and encoding", () => {
-    const matcher = createMatcher([{ path: "/api/:resource" }]);
-    const result = matcher(
-      new URL("/api/user%2Fprofile", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.resource, "user%2Fprofile");
-  });
-  test("Query parameters do not affect route matching", () => {
-    const matcher = createMatcher([{ path: "/search" }]);
-    const result = matcher(
-      new URL("/search?q=test&page=1", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/search");
-  });
-  test("Hash does not affect route matching", () => {
-    const matcher = createMatcher([{ path: "/page" }]);
-    const result = matcher(new URL("/page#section1", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/page");
-  });
-  test.todo("Case-sensitive matching", () => {
-    const matcher = createMatcher([{ path: "/API" }, { path: "/api" }]);
-    const result1 = matcher(new URL("/API", BASE_URL), BASE_URL);
-    const result2 = matcher(new URL("/api", BASE_URL), BASE_URL);
-    assert.equal(result1.matches.length, 1);
-    assert.equal(result1.matches[0].path, "/API");
-    assert.equal(result2.matches.length, 1);
-    assert.equal(result2.matches[0].path, "/api");
-  });
-  test("Username and password in baseURL should be ignored", () => {
-    const customBase = new URL("https://uname@pwlocalhost:3000/app/");
-    const matcher = createMatcher([{ path: "/test" }]);
-    const result = matcher(
-      new URL("https://uname2@pw2localhost:3000/app/test"),
-      customBase
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "/test");
-  });
-  test("Empty string handling in nested routes", () => {
-    const matcher = createMatcher([
-      {
-        path: "/parent",
-        children: [{ path: "" }, { path: "child" }]
-      }
-    ]);
-    const result1 = matcher(new URL("/parent", BASE_URL), BASE_URL);
-    assert.equal(result1.matches.length, 2);
-    assert.equal(result1.matches[0].path, "/parent");
-    assert.equal(result1.matches[1].path, "");
-    const result2 = matcher(new URL("/parent/child", BASE_URL), BASE_URL);
-    assert.equal(result2.matches.length, 2);
-    assert.equal(result2.matches[0].path, "/parent");
-    assert.equal(result2.matches[1].path, "child");
-  });
-  test("Route component configuration persistence", () => {
-    const TestComponent = () => "test";
-    const matcher = createMatcher([
-      {
-        path: "/component-test",
-        component: TestComponent
-      }
-    ]);
-    const result = matcher(new URL("/component-test", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, TestComponent);
-  });
-  test("Route redirect configuration persistence", () => {
-    const redirectTarget = "/new-path";
-    const matcher = createMatcher([
-      {
-        path: "/old-path",
-        redirect: redirectTarget
-      }
-    ]);
-    const result = matcher(new URL("/old-path", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].redirect, redirectTarget);
-  });
-  test("Numeric parameter parsing", () => {
-    const matcher = createMatcher([{ path: "/user/:id(\\d+)" }]);
-    const result1 = matcher(new URL("/user/123", BASE_URL), BASE_URL);
-    assert.equal(result1.matches.length, 1);
-    assert.equal(result1.params.id, "123");
-    const result2 = matcher(new URL("/user/abc", BASE_URL), BASE_URL);
-    assert.equal(result2.matches.length, 0);
-  });
-  test("Route matching depth-first strategy verification", () => {
-    var _a, _b, _c;
-    const matcher = createMatcher([
-      {
-        path: "/level1",
-        meta: { level: 1 },
-        children: [
-          {
-            path: "level2",
-            meta: { level: 2 },
-            children: [
-              {
-                path: "level3",
-                meta: { level: 3 }
-              }
-            ]
-          }
-        ]
-      }
-    ]);
-    const result = matcher(
-      new URL("/level1/level2/level3", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 3);
-    assert.equal((_a = result.matches[0].meta) == null ? void 0 : _a.level, 1);
-    assert.equal((_b = result.matches[1].meta) == null ? void 0 : _b.level, 2);
-    assert.equal((_c = result.matches[2].meta) == null ? void 0 : _c.level, 3);
-  });
-  test("Empty meta object default handling", () => {
-    const matcher = createMatcher([{ path: "/no-meta" }]);
-    const result = matcher(new URL("/no-meta", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.isObject(result.matches[0].meta);
-    assert.deepEqual(result.matches[0].meta, {});
-  });
-  test("Path normalization handling", () => {
-    const matcher = createMatcher([{ path: "/test//double//slash" }]);
-    const result = matcher(
-      new URL("/test/double/slash", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-  });
-  test("Error path configuration handling", () => {
-    const matcher1 = createMatcher([{ path: "" }]);
-    const result1 = matcher1(new URL("/", BASE_URL), BASE_URL);
-    assert.equal(result1.matches.length, 1);
-    const matcher2 = createMatcher([{ path: "/" }]);
-    const result2 = matcher2(new URL("/", BASE_URL), BASE_URL);
-    assert.equal(result2.matches.length, 1);
-  });
-  test("Empty parameter handling", () => {
-    const matcher = createMatcher([{ path: "/user/:id" }]);
-    const result = matcher(new URL("/user/", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-  });
-  test("Route configuration completeness verification", () => {
-    var _a, _b, _c, _d, _e, _f;
-    const TestComponent = () => "test";
-    const asyncComponent = async () => TestComponent;
-    const beforeEnter = async (to, from, router) => void 0;
-    const matcher = createMatcher([
-      {
-        path: "/complete",
-        component: TestComponent,
-        asyncComponent,
-        beforeEnter,
-        meta: {
-          title: "Complete Route",
-          requiresAuth: true,
-          permissions: ["read", "write"]
-        },
-        children: [
-          {
-            path: "child",
-            component: TestComponent
-          }
-        ]
-      }
-    ]);
-    const result = matcher(new URL("/complete", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, TestComponent);
-    assert.equal(result.matches[0].asyncComponent, asyncComponent);
-    assert.equal(result.matches[0].beforeEnter, beforeEnter);
-    assert.equal((_b = (_a = result.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.title, "Complete Route");
-    assert.equal((_d = (_c = result.matches[0]) == null ? void 0 : _c.meta) == null ? void 0 : _d.requiresAuth, true);
-    assert.deepEqual((_f = (_e = result.matches[0]) == null ? void 0 : _e.meta) == null ? void 0 : _f.permissions, [
-      "read",
-      "write"
-    ]);
-    assert.equal(result.matches[0].children.length, 1);
-  });
-  test.todo("Route conflict and priority handling", () => {
-    var _a, _b, _c, _d;
-    const matcher = createMatcher([
-      {
-        path: "/conflict/:id",
-        meta: { priority: 1 }
-      },
-      {
-        path: "/conflict/special",
-        meta: { priority: 2 }
-      },
-      {
-        path: "/conflict/:rest*",
-        meta: { priority: 3 }
-      }
-    ]);
-    const result1 = matcher(
-      new URL("/conflict/special", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result1.matches.length, 1);
-    assert.equal((_b = (_a = result1.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.priority, 2);
-    const result2 = matcher(new URL("/conflict/123", BASE_URL), BASE_URL);
-    assert.equal(result2.matches.length, 1);
-    assert.equal((_d = (_c = result2.matches[0]) == null ? void 0 : _c.meta) == null ? void 0 : _d.priority, 1);
-    assert.equal(result2.params.id, "123");
-  });
-  test("Multi-level nested parameter extraction", () => {
-    const matcher = createMatcher([
-      {
-        path: "/api",
-        children: [
-          {
-            path: "v:version",
-            children: [
-              {
-                path: ":resource",
-                children: [
-                  {
-                    path: ":id",
-                    children: [{ path: ":action" }]
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ]);
-    const result = matcher(
-      new URL("/api/v1/users/123/edit", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 5);
-    assert.equal(result.params.version, "1");
-    assert.equal(result.params.resource, "users");
-    assert.equal(result.params.id, "123");
-    assert.equal(result.params.action, "edit");
-  });
-  test("Route override configuration handling", () => {
-    var _a, _b;
-    const overrideHandler = (to, from, router) => {
-      return async (toRoute, fromRoute, routerInstance) => ({
-        data: "test"
-      });
-    };
-    const matcher = createMatcher([
-      {
-        path: "/override-test",
-        override: overrideHandler,
-        meta: { type: "hybrid" }
-      }
-    ]);
-    const result = matcher(new URL("/override-test", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].override, overrideHandler);
-    assert.equal((_b = (_a = result.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.type, "hybrid");
-  });
-  test("Application configuration handling", () => {
-    const appConfig = "test-app";
-    const appCallback = () => ({ mount: () => {
-    }, unmount: () => {
-    } });
-    const matcher = createMatcher([
-      { path: "/app1", app: appConfig },
-      { path: "/app2", app: appCallback }
-    ]);
-    const result1 = matcher(new URL("/app1", BASE_URL), BASE_URL);
-    assert.equal(result1.matches.length, 1);
-    assert.equal(result1.matches[0].app, appConfig);
-    const result2 = matcher(new URL("/app2", BASE_URL), BASE_URL);
-    assert.equal(result2.matches.length, 1);
-    assert.equal(result2.matches[0].app, appCallback);
-  });
-  test("Complex wildcard and parameter combinations", () => {
-    const matcher = createMatcher([{ path: "/files/:category/:rest*" }]);
-    const result = matcher(
-      new URL("/files/documents/folder1/folder2/view", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.params.category, "documents");
-    assert.deepEqual(result.params.rest, ["folder1", "folder2", "view"]);
-  });
-  test("Route redirect configuration verification", () => {
-    const redirectTarget = "/new-location";
-    const redirectFunction = () => "/dynamic-location";
-    const matcher = createMatcher([
-      {
-        path: "/redirect-string",
-        redirect: redirectTarget
-      },
-      {
-        path: "/redirect-function",
-        redirect: redirectFunction
-      }
-    ]);
-    const result1 = matcher(
-      new URL("/redirect-string", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result1.matches.length, 1);
-    assert.equal(result1.matches[0].redirect, redirectTarget);
-    const result2 = matcher(
-      new URL("/redirect-function", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result2.matches.length, 1);
-    assert.equal(result2.matches[0].redirect, redirectFunction);
-  });
-  test("Route guard configuration verification", () => {
-    var _a, _b;
-    const beforeEnter = async (to, from, router) => void 0;
-    const beforeUpdate = async (to, from, router) => void 0;
-    const beforeLeave = async (to, from, router) => "/cancel";
-    const matcher = createMatcher([
-      {
-        path: "/guarded",
-        beforeEnter,
-        beforeUpdate,
-        beforeLeave,
-        meta: { protected: true }
-      }
-    ]);
-    const result = matcher(new URL("/guarded", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].beforeEnter, beforeEnter);
-    assert.equal(result.matches[0].beforeUpdate, beforeUpdate);
-    assert.equal(result.matches[0].beforeLeave, beforeLeave);
-    assert.equal((_b = (_a = result.matches[0]) == null ? void 0 : _a.meta) == null ? void 0 : _b.protected, true);
-  });
-  test.todo("matcher performance boundary test", () => {
-    const routes = [];
-    for (let i = 0; i < 500; i++) {
-      routes.push({
-        path: "/category".concat(i, "/:id"),
-        children: [
-          {
-            path: "subcategory/:subId"
-          }
-        ]
-      });
-    }
-    const matcher = createMatcher(routes);
-    const startTime = performance.now();
-    const result = matcher(new URL("/nonexistent", BASE_URL), BASE_URL);
-    const endTime = performance.now();
-    assert.equal(result.matches.length, 0);
-    assert.isTrue(endTime - startTime < 50);
-  });
-  test("params type and value verification", () => {
-    const matcher = createMatcher([
-      { path: "/typed/:stringParam/:numberParam(\\d+)/:optionalParam?" }
-    ]);
-    const result = matcher(
-      new URL("/typed/hello/123/extra", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(typeof result.params.stringParam, "string");
-    assert.equal(result.params.stringParam, "hello");
-    assert.equal(typeof result.params.numberParam, "string");
-    assert.equal(result.params.numberParam, "123");
-    assert.equal(result.params.optionalParam, "extra");
-  });
-  test("Special URL encoding scenarios", () => {
-    const matcher = createMatcher([{ path: "/encoded/:param" }]);
-    const testCases = [
-      { input: "/encoded/hello%20world", expected: "hello%20world" },
-      {
-        input: "/encoded/%E4%B8%AD%E6%96%87",
-        expected: "%E4%B8%AD%E6%96%87"
-      },
-      {
-        input: "/encoded/user%40domain.com",
-        expected: "user%40domain.com"
-      },
-      { input: "/encoded/path%2Fto%2Ffile", expected: "path%2Fto%2Ffile" }
-    ];
-    testCases.forEach(({ input, expected }) => {
-      const result = matcher(new URL(input, BASE_URL), BASE_URL);
-      assert.equal(result.matches.length, 1);
-      assert.equal(result.params.param, expected);
-    });
-  });
-  test("Error configuration tolerance handling", () => {
-    const emptyMatcher = createMatcher([]);
-    const emptyResult = emptyMatcher(new URL("/any", BASE_URL), BASE_URL);
-    assert.equal(emptyResult.matches.length, 0);
-    assert.deepEqual(emptyResult.params, {});
-    const matcher = createMatcher([
-      { path: "/valid" },
-      ...process.env.NODE_ENV === "test" ? [] : []
-    ]);
-    const result = matcher(new URL("/valid", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-  });
-  test("Wildcard route matching - optional wildcard", () => {
-    const routes = [
-      { path: "/files/:path*", component: "FilesPage" },
-      { path: "/api/:section/data", component: "ApiDataPage" },
-      { path: "/:rest*", component: "CatchAllPage" }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(
-      new URL("/files/document.pdf", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.deepEqual(result.params.path, ["document.pdf"]);
-    result = matcher(
-      new URL("/files/images/photo.jpg", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.deepEqual(result.params.path, ["images", "photo.jpg"]);
-    result = matcher(new URL("/files/", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, void 0);
-    result = matcher(new URL("/files", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, void 0);
-    result = matcher(new URL("/api/v1/data", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ApiDataPage");
-    assert.equal(result.params.section, "v1");
-    result = matcher(new URL("/anything/else", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "CatchAllPage");
-    assert.deepEqual(result.params.rest, ["anything", "else"]);
-  });
-  test("Repeatable parameter route matching - + modifier", () => {
-    const routes = [
-      { path: "/chapters/:chapters+", component: "ChaptersPage" },
-      {
-        path: "/categories/:categories+/items",
-        component: "CategoriesItemsPage"
-      },
-      { path: "/tags/:tags+/posts/:postId", component: "TaggedPostPage" }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/chapters/intro", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ChaptersPage");
-    assert.deepEqual(result.params.chapters, ["intro"]);
-    result = matcher(
-      new URL("/chapters/intro/basics/advanced", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ChaptersPage");
-    assert.deepEqual(result.params.chapters, [
-      "intro",
-      "basics",
-      "advanced"
-    ]);
-    result = matcher(
-      new URL("/categories/tech/programming/items", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "CategoriesItemsPage");
-    assert.deepEqual(result.params.categories, ["tech", "programming"]);
-    result = matcher(
-      new URL("/tags/react/typescript/hooks/posts/123", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "TaggedPostPage");
-    assert.deepEqual(result.params.tags, ["react", "typescript", "hooks"]);
-    assert.equal(result.params.postId, "123");
-  });
-  test("Repeatable parameter route matching - * modifier", () => {
-    const routes = [
-      { path: "/path/:segments*", component: "DynamicPathPage" },
-      { path: "/files/:path*/download", component: "DownloadPage" }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/path", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "DynamicPathPage");
-    assert.equal(result.params.segments, void 0);
-    result = matcher(new URL("/path/a", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "DynamicPathPage");
-    assert.equal(result.params.segments, "a");
-    result = matcher(new URL("/path/a/b/c/d", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "DynamicPathPage");
-    assert.deepEqual(result.params.segments, ["a", "b", "c", "d"]);
-    result = matcher(new URL("/files/download", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "DownloadPage");
-    assert.equal(result.params.path, void 0);
-    result = matcher(new URL("/files/a/download", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "DownloadPage");
-    assert.equal(result.params.path, "a");
-    result = matcher(
-      new URL("/files/docs/images/download", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "DownloadPage");
-    assert.deepEqual(result.params.path, ["docs", "images"]);
-  });
-  test("Custom regular expression route matching", () => {
-    const routes = [
-      { path: "/order/:orderId(\\d+)", component: "OrderPage" },
-      { path: "/user/:username([a-zA-Z0-9_]+)", component: "UserPage" },
-      { path: "/product/:productName", component: "ProductPage" },
-      { path: "/api/v:version(\\d+)", component: "ApiPage" },
-      { path: "/hex/:color([0-9a-fA-F]{6})", component: "ColorPage" }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/order/12345", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "OrderPage");
-    assert.equal(result.params.orderId, "12345");
-    result = matcher(new URL("/order/abc123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-    result = matcher(new URL("/user/john_doe123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "UserPage");
-    assert.equal(result.params.username, "john_doe123");
-    result = matcher(new URL("/api/v2", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ApiPage");
-    assert.equal(result.params.version, "2");
-    result = matcher(new URL("/hex/FF0000", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ColorPage");
-    assert.equal(result.params.color, "FF0000");
-    result = matcher(new URL("/hex/GGGGGG", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-    result = matcher(new URL("/product/laptop-pro", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ProductPage");
-    assert.equal(result.params.productName, "laptop-pro");
-  });
-  test("Repeatable parameter and custom regular expression route matching", () => {
-    const routes = [
-      { path: "/numbers/:nums(\\d+)+", component: "NumbersPage" },
-      { path: "/codes/:codes([A-Z]{2,3})+", component: "CodesPage" },
-      { path: "/optional/:items(\\d+)*", component: "OptionalItemsPage" },
-      {
-        path: "/mixed/:ids(\\d+)+/info/:codes([A-Z]+)*",
-        component: "MixedPage"
-      }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/numbers/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "NumbersPage");
-    assert.deepEqual(result.params.nums, ["123"]);
-    result = matcher(new URL("/numbers/123/456/789", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "NumbersPage");
-    assert.deepEqual(result.params.nums, ["123", "456", "789"]);
-    result = matcher(new URL("/codes/US/UK/CA", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "CodesPage");
-    assert.deepEqual(result.params.codes, ["US", "UK", "CA"]);
-    result = matcher(new URL("/optional", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "OptionalItemsPage");
-    assert.equal(result.params.items, void 0);
-    result = matcher(new URL("/optional/100/200/300", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "OptionalItemsPage");
-    assert.deepEqual(result.params.items, ["100", "200", "300"]);
-    result = matcher(
-      new URL("/mixed/111/222/info/ABC/DEF", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "MixedPage");
-    assert.deepEqual(result.params.ids, ["111", "222"]);
-    assert.deepEqual(result.params.codes, ["ABC", "DEF"]);
-    result = matcher(new URL("/numbers/abc/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-  });
-  test("Optional parameter route matching - basic usage", () => {
-    const routes = [
-      { path: "/users/:userId?", component: "UsersPage" },
-      { path: "/posts/:postId?/comments", component: "CommentsPage" },
-      { path: "/search/:query?/:page?", component: "SearchPage" },
-      {
-        path: "/profile/:section?/:subsection?",
-        component: "ProfilePage"
-      }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/users", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "UsersPage");
-    assert.equal(result.params.userId, void 0);
-    result = matcher(new URL("/users/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "UsersPage");
-    assert.equal(result.params.userId, "123");
-    result = matcher(new URL("/posts/comments", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "CommentsPage");
-    assert.equal(result.params.postId, void 0);
-    result = matcher(new URL("/posts/456/comments", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "CommentsPage");
-    assert.equal(result.params.postId, "456");
-    result = matcher(new URL("/search", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "SearchPage");
-    assert.equal(result.params.query, void 0);
-    assert.equal(result.params.page, void 0);
-    result = matcher(new URL("/search/react", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "SearchPage");
-    assert.equal(result.params.query, "react");
-    assert.equal(result.params.page, void 0);
-    result = matcher(new URL("/search/react/2", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "SearchPage");
-    assert.equal(result.params.query, "react");
-    assert.equal(result.params.page, "2");
-  });
-  test("Optional parameter and custom regular expression route matching", () => {
-    const routes = [
-      { path: "/users/:userId(\\d+)?", component: "UsersPage" },
-      {
-        path: "/products/:category([a-z]+)?/:productId(\\d+)?",
-        component: "ProductsPage"
-      },
-      {
-        path: "/articles/:year(\\d{4})?/:month(\\d{1,2})?/:slug?",
-        component: "ArticlesPage"
-      },
-      {
-        path: "/api/:version(v\\d+)?/users/:userId(\\d+)?",
-        component: "ApiUsersPage"
-      }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/users", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "UsersPage");
-    assert.equal(result.params.userId, void 0);
-    result = matcher(new URL("/users/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "UsersPage");
-    assert.equal(result.params.userId, "123");
-    result = matcher(new URL("/users/abc", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-    result = matcher(new URL("/products", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ProductsPage");
-    assert.equal(result.params.category, void 0);
-    assert.equal(result.params.productId, void 0);
-    result = matcher(new URL("/products/electronics", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ProductsPage");
-    assert.equal(result.params.category, "electronics");
-    assert.equal(result.params.productId, void 0);
-    result = matcher(
-      new URL("/products/electronics/456", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ProductsPage");
-    assert.equal(result.params.category, "electronics");
-    assert.equal(result.params.productId, "456");
-    result = matcher(new URL("/articles/2024", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ArticlesPage");
-    assert.equal(result.params.year, "2024");
-    assert.equal(result.params.month, void 0);
-    assert.equal(result.params.slug, void 0);
-    result = matcher(
-      new URL("/articles/2024/03/my-post", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ArticlesPage");
-    assert.equal(result.params.year, "2024");
-    assert.equal(result.params.month, "03");
-    assert.equal(result.params.slug, "my-post");
-    result = matcher(new URL("/api/v2/users/789", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ApiUsersPage");
-    assert.equal(result.params.version, "v2");
-    assert.equal(result.params.userId, "789");
-    result = matcher(new URL("/api/users", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ApiUsersPage");
-    assert.equal(result.params.version, void 0);
-    assert.equal(result.params.userId, void 0);
-  });
-  test("Complex route pattern combination matching", () => {
-    const routes = [
-      {
-        path: "/api/v:version(\\d+)/users/:userId(\\d+)/posts/:postIds(\\d+)+",
-        component: "UserPostsPage"
-      },
-      {
-        path: "/files/:folders([a-zA-Z0-9_-]+)*/download/:filename+",
-        component: "FileDownloadPage"
-      },
-      {
-        path: "/shop/:categories([a-z]+)+/items/:itemId(\\d+)?/reviews/:reviewIds(\\d+)*",
-        component: "ShopReviewsPage"
-      },
-      {
-        path: "/admin/users/:userIds(\\d+)+/roles/:roleNames([a-z]+)*",
-        component: "AdminUserRolesPage"
-      }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(
-      new URL("/api/v1/users/123/posts/456/789", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "UserPostsPage");
-    assert.equal(result.params.version, "1");
-    assert.equal(result.params.userId, "123");
-    assert.deepEqual(result.params.postIds, ["456", "789"]);
-    result = matcher(
-      new URL("/files/docs/images/download/photo.jpg", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FileDownloadPage");
-    assert.deepEqual(result.params.folders, ["docs", "images"]);
-    assert.deepEqual(result.params.filename, ["photo.jpg"]);
-    result = matcher(
-      new URL("/files/download/readme.txt", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FileDownloadPage");
-    assert.equal(result.params.folders, void 0);
-    assert.deepEqual(result.params.filename, ["readme.txt"]);
-    result = matcher(
-      new URL("/shop/electronics/computers/items/123/reviews/", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ShopReviewsPage");
-    assert.deepEqual(result.params.categories, [
-      "electronics",
-      "computers"
-    ]);
-    assert.equal(result.params.itemId, "123");
-    assert.equal(result.params.reviewIds, void 0);
-    result = matcher(
-      new URL("/shop/books/items/reviews/101/102", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ShopReviewsPage");
-    assert.deepEqual(result.params.categories, ["books"]);
-    assert.equal(result.params.itemId, void 0);
-    assert.deepEqual(result.params.reviewIds, ["101", "102"]);
-    result = matcher(
-      new URL("/admin/users/100/200/300/roles/admin/moderator", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "AdminUserRolesPage");
-    assert.deepEqual(result.params.userIds, ["100", "200", "300"]);
-    assert.deepEqual(result.params.roleNames, ["admin", "moderator"]);
-    result = matcher(
-      new URL("/admin/users/100/roles/", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "AdminUserRolesPage");
-    assert.deepEqual(result.params.userIds, ["100"]);
-    assert.equal(result.params.roleNames, void 0);
-  });
-  test("Advanced route pattern edge cases", () => {
-    const routes = [
-      {
-        path: "/test/:param(\\d+)?/:param2(\\d+)+",
-        component: "TestPage"
-      },
-      { path: "/empty/:empty*", component: "EmptyPage" },
-      { path: "/strict/:id(\\d{3})", component: "StrictPage" }
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(new URL("/test/123/456", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "TestPage");
-    assert.equal(result.params.param, "123");
-    assert.deepEqual(result.params.param2, ["456"]);
-    result = matcher(new URL("/test/123/456/789", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "TestPage");
-    assert.equal(result.params.param, "123");
-    assert.deepEqual(result.params.param2, ["456", "789"]);
-    result = matcher(new URL("/empty/", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "EmptyPage");
-    assert.equal(result.params.empty, void 0);
-    result = matcher(new URL("/strict/123", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "StrictPage");
-    assert.equal(result.params.id, "123");
-    result = matcher(new URL("/strict/1234", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-    result = matcher(new URL("/strict/12", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 0);
-  });
-  test("Empty path wildcard", () => {
-    assert.throws(
-      () => createMatcher([{ path: "*" }]),
-      "Unexpected MODIFIER"
-    );
-    let result = createMatcher([{ path: "(.*)" }])(
-      new URL("/users/a/b/c", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "(.*)");
-    result = createMatcher([{ path: "(.*)*" }])(
-      new URL("/users/a/b/c", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].path, "(.*)*");
-  });
-  test.todo("Wildcard route matching - new version", () => {
-    const routes = [
-      { path: "/files{/*path}/:file{.:ext}", component: "FilesPage" },
-      // /files/:path*/:file.:ext?
-      { path: "/api/*section/data", component: "ApiDataPage" },
-      // /api/:section?/data
-      { path: "{/*rest}", component: "CatchAllPage" }
-      // /:rest*
-    ];
-    const matcher = createMatcher(routes);
-    let result = matcher(
-      new URL("/files/document.pdf", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, void 0);
-    assert.equal(result.params.file, "document");
-    assert.equal(result.params.ext, "pdf");
-    result = matcher(
-      new URL("/files/images/photo.jpg", BASE_URL),
-      BASE_URL
-    );
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, ["images"]);
-    assert.equal(result.params.file, "photo");
-    assert.equal(result.params.ext, "jpg");
-    result = matcher(new URL("/files/images/photo", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, ["images"]);
-    assert.equal(result.params.file, "photo");
-    assert.equal(result.params.ext, void 0);
-    result = matcher(new URL("/files/", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, void 0);
-    result = matcher(new URL("/files", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "FilesPage");
-    assert.equal(result.params.path, void 0);
-    result = matcher(new URL("/api/v1/data", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "ApiDataPage");
-    assert.equal(result.params.section, "v1");
-    result = matcher(new URL("/anything/else", BASE_URL), BASE_URL);
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].component, "CatchAllPage");
-    assert.deepEqual(result.params.rest, ["anything", "else"]);
-  });
-});