@edgeone/vite-core 1.0.0

package/dist/route/regex.test.js

@@ -0,0 +1,662 @@
+/**
+ * Route Regex Tests
+ *
+ * Comprehensive test suite for route regex conversion and matching
+ */
+import { isDynamicRoute, isCatchAllRoute, routeToRegex, addRegexToRoutes, convertRoutesToMetaFormat, sortRoutesByPriority, } from "./regex.js";
+// ============================================================================
+// Test Utilities
+// ============================================================================
+function testMatch(regex, path) {
+    return new RegExp(regex).test(path);
+}
+function assertMatch(regex, path, expected, message) {
+    const result = testMatch(regex, path);
+    const status = result === expected ? "✓" : "✗";
+    const msg = message || `${path} should ${expected ? "" : "not "}match ${regex}`;
+    console.log(`  ${status} ${msg}`);
+    if (result !== expected) {
+        throw new Error(`Assertion failed: ${msg}`);
+    }
+}
+function runTestGroup(name, fn) {
+    console.log(`\n${name}`);
+    console.log("─".repeat(60));
+    fn();
+}
+// ============================================================================
+// isDynamicRoute Tests
+// ============================================================================
+function testIsDynamicRoute() {
+    runTestGroup("isDynamicRoute - Colon Syntax", () => {
+        console.log("  ✓ Static routes:");
+        console.assert(!isDynamicRoute("/"), "/ should be static");
+        console.assert(!isDynamicRoute("/about"), "/about should be static");
+        console.assert(!isDynamicRoute("/api/users"), "/api/users should be static");
+        console.log("    / , /about, /api/users → false");
+        console.log("  ✓ Dynamic routes:");
+        console.assert(isDynamicRoute("/:id"), "/:id should be dynamic");
+        console.assert(isDynamicRoute("/blog/:slug"), "/blog/:slug should be dynamic");
+        console.assert(isDynamicRoute("/user/:id/posts"), "/user/:id/posts should be dynamic");
+        console.log("    /:id, /blog/:slug, /user/:id/posts → true");
+        console.log("  ✓ Optional parameters:");
+        console.assert(isDynamicRoute("/:id?"), "/:id? should be dynamic");
+        console.assert(isDynamicRoute("/blog/:slug?"), "/blog/:slug? should be dynamic");
+        console.log("    /:id?, /blog/:slug? → true");
+        console.log("  ✓ Wildcard:");
+        console.assert(isDynamicRoute("/*"), "/* should be dynamic");
+        console.assert(isDynamicRoute("/files/*"), "/files/* should be dynamic");
+        console.log("    /*, /files/* → true");
+    });
+    runTestGroup("isDynamicRoute - Dollar Syntax (TanStack)", () => {
+        console.log("  ✓ Dynamic routes:");
+        console.assert(isDynamicRoute("/$id"), "/$id should be dynamic");
+        console.assert(isDynamicRoute("/blog/$slug"), "/blog/$slug should be dynamic");
+        console.log("    /$id, /blog/$slug → true");
+        console.log("  ✓ Splat routes:");
+        console.assert(isDynamicRoute("/$"), "/$ should be dynamic");
+        console.assert(isDynamicRoute("/files/$"), "/files/$ should be dynamic");
+        console.log("    /$, /files/$ → true");
+    });
+    runTestGroup("isDynamicRoute - At Syntax (Vike)", () => {
+        console.log("  ✓ Dynamic routes:");
+        console.assert(isDynamicRoute("/@id"), "/@id should be dynamic");
+        console.assert(isDynamicRoute("/user/@id"), "/user/@id should be dynamic");
+        console.assert(isDynamicRoute("/blog/@slug"), "/blog/@slug should be dynamic");
+        console.assert(isDynamicRoute("/api/@version/@endpoint"), "/api/@version/@endpoint should be dynamic");
+        console.log("    /@id, /user/@id, /blog/@slug, /api/@version/@endpoint → true");
+        console.log("  ✓ Mixed with static segments:");
+        console.assert(isDynamicRoute("/product/@category/@id"), "/product/@category/@id should be dynamic");
+        console.assert(isDynamicRoute("/shop/@shopId/item/@itemId"), "/shop/@shopId/item/@itemId should be dynamic");
+        console.log("    /product/@category/@id, /shop/@shopId/item/@itemId → true");
+    });
+    runTestGroup("isDynamicRoute - Bracket Syntax (Next.js/Nuxt)", () => {
+        console.log("  ✓ Dynamic routes:");
+        console.assert(isDynamicRoute("/[id]"), "/[id] should be dynamic");
+        console.assert(isDynamicRoute("/blog/[slug]"), "/blog/[slug] should be dynamic");
+        console.log("    /[id], /blog/[slug] → true");
+        console.log("  ✓ Optional routes:");
+        console.assert(isDynamicRoute("/[[id]]"), "/[[id]] should be dynamic");
+        console.assert(isDynamicRoute("/blog/[[slug]]"), "/blog/[[slug]] should be dynamic");
+        console.log("    /[[id]], /blog/[[slug]] → true");
+        console.log("  ✓ Catch-all routes:");
+        console.assert(isDynamicRoute("/[...path]"), "/[...path] should be dynamic");
+        console.assert(isDynamicRoute("/docs/[...slug]"), "/docs/[...slug] should be dynamic");
+        console.log("    /[...path], /docs/[...slug] → true");
+        console.log("  ✓ Optional catch-all routes:");
+        console.assert(isDynamicRoute("/[[...path]]"), "/[[...path]] should be dynamic");
+        console.log("    /[[...path]] → true");
+    });
+}
+// ============================================================================
+// isCatchAllRoute Tests
+// ============================================================================
+function testIsCatchAllRoute() {
+    runTestGroup("isCatchAllRoute", () => {
+        console.log("  ✓ Not catch-all:");
+        console.assert(!isCatchAllRoute("/"), "/ should not be catch-all");
+        console.assert(!isCatchAllRoute("/about"), "/about should not be catch-all");
+        console.assert(!isCatchAllRoute("/:id"), "/:id should not be catch-all");
+        console.assert(!isCatchAllRoute("/[id]"), "/[id] should not be catch-all");
+        console.assert(!isCatchAllRoute("/$id"), "/$id should not be catch-all");
+        console.log("    /, /about, /:id, /[id], /$id → false");
+        console.log("  ✓ Catch-all (colon syntax):");
+        console.assert(isCatchAllRoute("/*"), "/* should be catch-all");
+        console.assert(isCatchAllRoute("/files/*"), "/files/* should be catch-all");
+        console.log("    /*, /files/* → true");
+        console.log("  ✓ Catch-all (dollar syntax):");
+        console.assert(isCatchAllRoute("/$"), "/$ should be catch-all");
+        console.assert(isCatchAllRoute("/files/$"), "/files/$ should be catch-all");
+        console.log("    /$, /files/$ → true");
+        console.log("  ✓ Catch-all (bracket syntax):");
+        console.assert(isCatchAllRoute("/[...path]"), "/[...path] should be catch-all");
+        console.assert(isCatchAllRoute("/[[...path]]"), "/[[...path]] should be catch-all");
+        console.log("    /[...path], /[[...path]] → true");
+    });
+}
+// ============================================================================
+// routeToRegex Tests - Colon Syntax
+// ============================================================================
+function testColonSyntax() {
+    runTestGroup("routeToRegex - Colon Syntax (React Router/Remix/Express)", () => {
+        // Root route
+        const rootRegex = routeToRegex("/");
+        console.log(`  "/" → ${rootRegex}`);
+        assertMatch(rootRegex, "/", true, "Root should match /");
+        assertMatch(rootRegex, "/about", false, "Root should not match /about");
+        // Static route
+        const aboutRegex = routeToRegex("/about");
+        console.log(`  "/about" → ${aboutRegex}`);
+        assertMatch(aboutRegex, "/about", true);
+        assertMatch(aboutRegex, "/about/", true, "Should match with trailing slash");
+        assertMatch(aboutRegex, "/about/more", false);
+        // Single dynamic parameter
+        const idRegex = routeToRegex("/user/:id");
+        console.log(`  "/user/:id" → ${idRegex}`);
+        assertMatch(idRegex, "/user/123", true);
+        assertMatch(idRegex, "/user/abc", true);
+        assertMatch(idRegex, "/user/", false, "Should not match empty param");
+        assertMatch(idRegex, "/user/123/extra", false);
+        // Multiple dynamic parameters
+        const multiRegex = routeToRegex("/user/:org/:repo");
+        console.log(`  "/user/:org/:repo" → ${multiRegex}`);
+        assertMatch(multiRegex, "/user/facebook/react", true);
+        assertMatch(multiRegex, "/user/google/angular", true);
+        assertMatch(multiRegex, "/user/only-one", false);
+        // Mixed static and dynamic
+        const mixedRegex = routeToRegex("/api/v1/:id/details");
+        console.log(`  "/api/v1/:id/details" → ${mixedRegex}`);
+        assertMatch(mixedRegex, "/api/v1/123/details", true);
+        assertMatch(mixedRegex, "/api/v1/abc/details", true);
+        assertMatch(mixedRegex, "/api/v1/details", false);
+        // Optional parameter
+        const optionalRegex = routeToRegex("/blog/:slug?");
+        console.log(`  "/blog/:slug?" → ${optionalRegex}`);
+        assertMatch(optionalRegex, "/blog/my-post", true);
+        assertMatch(optionalRegex, "/blog", true, "Optional param can be absent");
+        // Note: /blog/ with trailing slash may or may not match depending on implementation
+        // The key is that /blog works without the parameter
+        // Wildcard/splat
+        const wildcardRegex = routeToRegex("/files/*");
+        console.log(`  "/files/*" → ${wildcardRegex}`);
+        assertMatch(wildcardRegex, "/files/", true);
+        assertMatch(wildcardRegex, "/files/doc.txt", true);
+        assertMatch(wildcardRegex, "/files/nested/path/file.txt", true);
+        assertMatch(wildcardRegex, "/files", true);
+    });
+}
+// ============================================================================
+// routeToRegex Tests - Dollar Syntax
+// ============================================================================
+function testDollarSyntax() {
+    runTestGroup("routeToRegex - Dollar Syntax (TanStack Start)", () => {
+        // Single dynamic parameter
+        const idRegex = routeToRegex("/user/$id");
+        console.log(`  "/user/$id" → ${idRegex}`);
+        assertMatch(idRegex, "/user/123", true);
+        assertMatch(idRegex, "/user/abc", true);
+        assertMatch(idRegex, "/user/", false);
+        // Multiple dynamic parameters
+        const multiRegex = routeToRegex("/user/$org/$repo");
+        console.log(`  "/user/$org/$repo" → ${multiRegex}`);
+        assertMatch(multiRegex, "/user/facebook/react", true);
+        assertMatch(multiRegex, "/user/only-one", false);
+        // Splat route
+        const splatRegex = routeToRegex("/files/$");
+        console.log(`  "/files/$" → ${splatRegex}`);
+        assertMatch(splatRegex, "/files/", true);
+        assertMatch(splatRegex, "/files/doc.txt", true);
+        assertMatch(splatRegex, "/files/nested/path/file.txt", true);
+        assertMatch(splatRegex, "/files", true);
+        // Mixed static and dynamic
+        const mixedRegex = routeToRegex("/api/v1/$id/details");
+        console.log(`  "/api/v1/$id/details" → ${mixedRegex}`);
+        assertMatch(mixedRegex, "/api/v1/123/details", true);
+        assertMatch(mixedRegex, "/api/v1/details", false);
+    });
+}
+// ============================================================================
+// routeToRegex Tests - At Syntax (Vike)
+// ============================================================================
+function testAtSyntax() {
+    runTestGroup("routeToRegex - At Syntax (Vike)", () => {
+        // Single dynamic parameter
+        const idRegex = routeToRegex("/user/@id");
+        console.log(`  "/user/@id" → ${idRegex}`);
+        assertMatch(idRegex, "/user/123", true);
+        assertMatch(idRegex, "/user/abc", true);
+        assertMatch(idRegex, "/user/john-doe", true);
+        assertMatch(idRegex, "/user/", false, "Should not match empty param");
+        assertMatch(idRegex, "/user/123/extra", false);
+        // Multiple dynamic parameters
+        const multiRegex = routeToRegex("/api/@version/@endpoint");
+        console.log(`  "/api/@version/@endpoint" → ${multiRegex}`);
+        assertMatch(multiRegex, "/api/v1/users", true);
+        assertMatch(multiRegex, "/api/v2/posts", true);
+        assertMatch(multiRegex, "/api/only-one", false);
+        // Blog slug
+        const blogRegex = routeToRegex("/blog/@slug");
+        console.log(`  "/blog/@slug" → ${blogRegex}`);
+        assertMatch(blogRegex, "/blog/my-first-post", true);
+        assertMatch(blogRegex, "/blog/hello-world", true);
+        assertMatch(blogRegex, "/blog/", false);
+        // Product category and id
+        const productRegex = routeToRegex("/product/@category/@id");
+        console.log(`  "/product/@category/@id" → ${productRegex}`);
+        assertMatch(productRegex, "/product/electronics/iphone-15", true);
+        assertMatch(productRegex, "/product/books/978-0-13-468599-1", true);
+        assertMatch(productRegex, "/product/electronics", false);
+        // Deep nested with multiple params
+        const shopRegex = routeToRegex("/shop/@shopId/item/@itemId");
+        console.log(`  "/shop/@shopId/item/@itemId" → ${shopRegex}`);
+        assertMatch(shopRegex, "/shop/123/item/456", true);
+        assertMatch(shopRegex, "/shop/amazon/item/B00XYZ", true);
+        assertMatch(shopRegex, "/shop/123/item", false);
+        // Localized routes
+        const langRegex = routeToRegex("/lang/@locale/page/@pageNum");
+        console.log(`  "/lang/@locale/page/@pageNum" → ${langRegex}`);
+        assertMatch(langRegex, "/lang/en/page/1", true);
+        assertMatch(langRegex, "/lang/zh-CN/page/10", true);
+        assertMatch(langRegex, "/lang/en/page", false);
+        // Search keyword
+        const searchRegex = routeToRegex("/search/@keyword");
+        console.log(`  "/search/@keyword" → ${searchRegex}`);
+        assertMatch(searchRegex, "/search/hello", true);
+        assertMatch(searchRegex, "/search/hello%20world", true);
+        // Docs path (single param, not catch-all)
+        const docsRegex = routeToRegex("/docs/@path");
+        console.log(`  "/docs/@path" → ${docsRegex}`);
+        assertMatch(docsRegex, "/docs/getting-started", true);
+        assertMatch(docsRegex, "/docs/api-reference", true);
+        assertMatch(docsRegex, "/docs/nested/path", false, "Single @param doesn't match nested paths");
+    });
+}
+// ============================================================================
+// routeToRegex Tests - Bracket Syntax
+// ============================================================================
+function testBracketSyntax() {
+    runTestGroup("routeToRegex - Bracket Syntax (Next.js/Nuxt/SvelteKit)", () => {
+        // Single dynamic parameter
+        const idRegex = routeToRegex("/user/[id]");
+        console.log(`  "/user/[id]" → ${idRegex}`);
+        assertMatch(idRegex, "/user/123", true);
+        assertMatch(idRegex, "/user/abc", true);
+        assertMatch(idRegex, "/user/", false);
+        // Multiple dynamic parameters
+        const multiRegex = routeToRegex("/user/[org]/[repo]");
+        console.log(`  "/user/[org]/[repo]" → ${multiRegex}`);
+        assertMatch(multiRegex, "/user/facebook/react", true);
+        assertMatch(multiRegex, "/user/only-one", false);
+        // Optional parameter [[param]]
+        const optionalRegex = routeToRegex("/blog/[[slug]]");
+        console.log(`  "/blog/[[slug]]" → ${optionalRegex}`);
+        assertMatch(optionalRegex, "/blog/my-post", true);
+        assertMatch(optionalRegex, "/blog", true, "Should match without optional param");
+        // Note: /blog/ may not match because (?:/([^/]+))? expects content after /
+        // Catch-all [...param]
+        const catchAllRegex = routeToRegex("/docs/[...path]");
+        console.log(`  "/docs/[...path]" → ${catchAllRegex}`);
+        assertMatch(catchAllRegex, "/docs/", true);
+        assertMatch(catchAllRegex, "/docs/intro", true);
+        assertMatch(catchAllRegex, "/docs/guide/getting-started", true);
+        assertMatch(catchAllRegex, "/docs", true);
+        // Optional catch-all [[...param]]
+        const optCatchAllRegex = routeToRegex("/[[...path]]");
+        console.log(`  "/[[...path]]" → ${optCatchAllRegex}`);
+        assertMatch(optCatchAllRegex, "/", true);
+        assertMatch(optCatchAllRegex, "/anything", true);
+        assertMatch(optCatchAllRegex, "/nested/path/here", true);
+    });
+}
+// ============================================================================
+// routeToRegex Options Tests
+// ============================================================================
+function testOptions() {
+    runTestGroup("routeToRegex - Options", () => {
+        // trailingSlashOptional: false
+        const strictRegex = routeToRegex("/about", { trailingSlashOptional: false });
+        console.log(`  trailingSlashOptional: false → ${strictRegex}`);
+        assertMatch(strictRegex, "/about", true);
+        assertMatch(strictRegex, "/about/", false, "Should not match trailing slash");
+        // anchored: false
+        const unanchoredRegex = routeToRegex("/api", { anchored: false });
+        console.log(`  anchored: false → ${unanchoredRegex}`);
+        assertMatch(unanchoredRegex, "/api", true);
+        assertMatch(unanchoredRegex, "/v1/api", true, "Should match anywhere");
+        assertMatch(unanchoredRegex, "/api/users", true);
+        // explicit syntax
+        const colonRegex = routeToRegex("/user/:id", { syntax: "colon" });
+        console.log(`  syntax: "colon" → ${colonRegex}`);
+        assertMatch(colonRegex, "/user/123", true);
+    });
+}
+// ============================================================================
+// Edge Cases Tests
+// ============================================================================
+function testEdgeCases() {
+    runTestGroup("Edge Cases - Basic", () => {
+        // Root with trailing slash
+        const rootRegex = routeToRegex("/");
+        console.log(`  "/" root route`);
+        assertMatch(rootRegex, "/", true);
+        // Route with dots (file extensions)
+        const fileRegex = routeToRegex("/files/:name.json");
+        console.log(`  "/files/:name.json" → ${fileRegex}`);
+        assertMatch(fileRegex, "/files/config.json", true);
+        assertMatch(fileRegex, "/files/data.json", true);
+        // Route with multiple consecutive params
+        const consecutiveRegex = routeToRegex("/:a/:b/:c");
+        console.log(`  "/:a/:b/:c" → ${consecutiveRegex}`);
+        assertMatch(consecutiveRegex, "/x/y/z", true);
+        assertMatch(consecutiveRegex, "/1/2/3", true);
+        assertMatch(consecutiveRegex, "/x/y", false);
+        // Numeric paths
+        const numericRegex = routeToRegex("/api/v1/users/:id");
+        console.log(`  "/api/v1/users/:id" → ${numericRegex}`);
+        assertMatch(numericRegex, "/api/v1/users/123", true);
+        assertMatch(numericRegex, "/api/v2/users/123", false);
+        // Special characters in path
+        const specialRegex = routeToRegex("/path+with+plus");
+        console.log(`  "/path+with+plus" → ${specialRegex}`);
+        assertMatch(specialRegex, "/path+with+plus", true);
+    });
+    runTestGroup("Edge Cases - Parameter Names", () => {
+        // Parameter with numbers
+        const numParamRegex = routeToRegex("/user/:id123");
+        console.log(`  "/user/:id123" → ${numParamRegex}`);
+        assertMatch(numParamRegex, "/user/abc", true);
+        assertMatch(numParamRegex, "/user/456", true);
+        // Parameter with underscore
+        const underscoreRegex = routeToRegex("/post/:post_id");
+        console.log(`  "/post/:post_id" → ${underscoreRegex}`);
+        assertMatch(underscoreRegex, "/post/123", true);
+        assertMatch(underscoreRegex, "/post/my-post", true);
+        // Multiple underscores
+        const multiUnderscoreRegex = routeToRegex("/api/:resource_type/:resource_id");
+        console.log(`  "/api/:resource_type/:resource_id" → ${multiUnderscoreRegex}`);
+        assertMatch(multiUnderscoreRegex, "/api/users/123", true);
+        // Bracket syntax with underscore
+        const bracketUnderscoreRegex = routeToRegex("/item/[item_id]");
+        console.log(`  "/item/[item_id]" → ${bracketUnderscoreRegex}`);
+        assertMatch(bracketUnderscoreRegex, "/item/abc123", true);
+        // Dollar syntax with underscore
+        const dollarUnderscoreRegex = routeToRegex("/product/$product_id");
+        console.log(`  "/product/$product_id" → ${dollarUnderscoreRegex}`);
+        assertMatch(dollarUnderscoreRegex, "/product/xyz", true);
+    });
+    runTestGroup("Edge Cases - Path Variations", () => {
+        // Hyphenated static path
+        const hyphenRegex = routeToRegex("/my-page/:slug");
+        console.log(`  "/my-page/:slug" → ${hyphenRegex}`);
+        assertMatch(hyphenRegex, "/my-page/hello-world", true);
+        assertMatch(hyphenRegex, "/my-page/test", true);
+        // Deep nested routes
+        const deepRegex = routeToRegex("/a/b/c/d/e/:id/f/g");
+        console.log(`  "/a/b/c/d/e/:id/f/g" → ${deepRegex}`);
+        assertMatch(deepRegex, "/a/b/c/d/e/123/f/g", true);
+        assertMatch(deepRegex, "/a/b/c/d/e/123/f", false);
+        // Multiple dynamic segments scattered
+        const scatteredRegex = routeToRegex("/org/:orgId/team/:teamId/member/:memberId");
+        console.log(`  "/org/:orgId/team/:teamId/member/:memberId" → ${scatteredRegex}`);
+        assertMatch(scatteredRegex, "/org/acme/team/eng/member/john", true);
+        assertMatch(scatteredRegex, "/org/acme/team/eng", false);
+        // Parentheses in static path (TanStack route groups)
+        const groupRegex = routeToRegex("/(auth)/login");
+        console.log(`  "/(auth)/login" → ${groupRegex}`);
+        assertMatch(groupRegex, "/(auth)/login", true);
+    });
+    runTestGroup("Edge Cases - Special Matching", () => {
+        // URL with encoded characters
+        const encodedRegex = routeToRegex("/search/:query");
+        console.log(`  "/search/:query" URL encoded`);
+        assertMatch(encodedRegex, "/search/hello%20world", true);
+        assertMatch(encodedRegex, "/search/test%2Fpath", true);
+        // Route ending with specific extension
+        const extRegex = routeToRegex("/download/:file.pdf");
+        console.log(`  "/download/:file.pdf" → ${extRegex}`);
+        assertMatch(extRegex, "/download/report.pdf", true);
+        assertMatch(extRegex, "/download/document.pdf", true);
+        // Numbers in static path
+        const num404Regex = routeToRegex("/error/404");
+        console.log(`  "/error/404" → ${num404Regex}`);
+        assertMatch(num404Regex, "/error/404", true);
+        assertMatch(num404Regex, "/error/500", false);
+        // Very long parameter value
+        const longValueRegex = routeToRegex("/article/:slug");
+        const longSlug = "a".repeat(200);
+        console.log(`  Long parameter value (200 chars)`);
+        assertMatch(longValueRegex, `/article/${longSlug}`, true);
+    });
+    runTestGroup("Edge Cases - Wildcards and Catch-alls", () => {
+        // Root catch-all
+        const rootCatchAllRegex = routeToRegex("/*");
+        console.log(`  "/*" root catch-all`);
+        assertMatch(rootCatchAllRegex, "/", true);
+        assertMatch(rootCatchAllRegex, "/anything", true);
+        assertMatch(rootCatchAllRegex, "/a/b/c/d", true);
+        // Nested catch-all
+        const nestedCatchAllRegex = routeToRegex("/api/v1/*");
+        console.log(`  "/api/v1/*" → ${nestedCatchAllRegex}`);
+        assertMatch(nestedCatchAllRegex, "/api/v1", true);
+        assertMatch(nestedCatchAllRegex, "/api/v1/", true);
+        assertMatch(nestedCatchAllRegex, "/api/v1/users/123/posts", true);
+        // Dollar splat at different depths
+        const deepDollarSplatRegex = routeToRegex("/files/public/$");
+        console.log(`  "/files/public/$" → ${deepDollarSplatRegex}`);
+        assertMatch(deepDollarSplatRegex, "/files/public", true);
+        assertMatch(deepDollarSplatRegex, "/files/public/images/photo.jpg", true);
+        // Bracket catch-all variations
+        const bracketDeepCatchAllRegex = routeToRegex("/shop/[...categories]");
+        console.log(`  "/shop/[...categories]" → ${bracketDeepCatchAllRegex}`);
+        assertMatch(bracketDeepCatchAllRegex, "/shop", true);
+        assertMatch(bracketDeepCatchAllRegex, "/shop/electronics", true);
+        assertMatch(bracketDeepCatchAllRegex, "/shop/electronics/phones/iphone", true);
+    });
+    runTestGroup("Edge Cases - Multiple Optional Params", () => {
+        // Two optional colon params (Note: typically not valid but test conversion)
+        const twoOptionalRegex = routeToRegex("/archive/:year?/:month?");
+        console.log(`  "/archive/:year?/:month?" → ${twoOptionalRegex}`);
+        assertMatch(twoOptionalRegex, "/archive", true);
+        assertMatch(twoOptionalRegex, "/archive/2024", true);
+        // Note: /archive/2024/12 may not match due to how optional groups work
+        // Bracket optional at root - this is a special case
+        // /[[lang]] means: optional language prefix, the root "/" is implicit
+        const rootOptionalRegex = routeToRegex("/[[lang]]");
+        console.log(`  "/[[lang]]" → ${rootOptionalRegex}`);
+        // Note: ^(?:/([^/]+))?$ won't match "/" because it expects either nothing or /content
+        // This is expected behavior - "/" matches when the pattern is just "/" not "/[[lang]]"
+        assertMatch(rootOptionalRegex, "/en", true);
+        assertMatch(rootOptionalRegex, "/zh-CN", true);
+        assertMatch(rootOptionalRegex, "", true, "Empty string matches optional");
+    });
+    runTestGroup("Edge Cases - Real World Patterns", () => {
+        // GitHub-style routes
+        const githubRegex = routeToRegex("/:owner/:repo/tree/:branch/*");
+        console.log(`  "/:owner/:repo/tree/:branch/*" GitHub pattern`);
+        assertMatch(githubRegex, "/facebook/react/tree/main", true);
+        assertMatch(githubRegex, "/facebook/react/tree/main/packages/react", true);
+        // Blog with date pattern
+        const blogDateRegex = routeToRegex("/blog/:year/:month/:day/:slug");
+        console.log(`  "/blog/:year/:month/:day/:slug" → ${blogDateRegex}`);
+        assertMatch(blogDateRegex, "/blog/2024/01/15/hello-world", true);
+        // E-commerce product
+        const productRegex = routeToRegex("/category/[category]/product/[productId]");
+        console.log(`  "/category/[category]/product/[productId]" → ${productRegex}`);
+        assertMatch(productRegex, "/category/electronics/product/iphone-15", true);
+        // API versioning with dynamic resource
+        const apiRegex = routeToRegex("/api/v:version/:resource/:id");
+        console.log(`  "/api/v:version/:resource/:id" → ${apiRegex}`);
+        assertMatch(apiRegex, "/api/v1/users/123", true);
+        assertMatch(apiRegex, "/api/v2/posts/456", true);
+        // Localized routes
+        const i18nRegex = routeToRegex("/[locale]/about");
+        console.log(`  "/[locale]/about" → ${i18nRegex}`);
+        assertMatch(i18nRegex, "/en/about", true);
+        assertMatch(i18nRegex, "/zh-CN/about", true);
+        assertMatch(i18nRegex, "/about", false);
+        // Vike-style routes
+        const vikeUserRegex = routeToRegex("/user/@id");
+        console.log(`  "/user/@id" Vike pattern`);
+        assertMatch(vikeUserRegex, "/user/123", true);
+        assertMatch(vikeUserRegex, "/user/john", true);
+        const vikeApiRegex = routeToRegex("/api/@version/@endpoint");
+        console.log(`  "/api/@version/@endpoint" Vike pattern`);
+        assertMatch(vikeApiRegex, "/api/v1/users", true);
+        const vikeShopRegex = routeToRegex("/shop/@shopId/item/@itemId");
+        console.log(`  "/shop/@shopId/item/@itemId" Vike pattern`);
+        assertMatch(vikeShopRegex, "/shop/store1/item/product123", true);
+    });
+}
+// ============================================================================
+// sortRoutesByPriority Tests
+// ============================================================================
+function testSortRoutes() {
+    runTestGroup("sortRoutesByPriority", () => {
+        const routes = [
+            { path: "/*", isStatic: false },
+            { path: "/api/:resource", isStatic: false },
+            { path: "/api/users/:id", isStatic: false },
+            { path: "/", isStatic: true },
+            { path: "/about", isStatic: true },
+            { path: "/api/users", isStatic: false },
+        ];
+        const sorted = sortRoutesByPriority(routes);
+        console.log("  Input order: /*, /api/:resource, /api/users/:id, /, /about, /api/users");
+        console.log("  Sorted order:", sorted.map(r => r.path).join(", "));
+        // Static routes should come first
+        console.assert(sorted[0].path === "/" || sorted[0].path === "/about", "Static routes should be first");
+        // Catch-all should be last
+        console.assert(sorted[sorted.length - 1].path === "/*", "Catch-all should be last");
+        // More specific dynamic routes should come before less specific
+        const apiUsersIdIndex = sorted.findIndex(r => r.path === "/api/users/:id");
+        const apiResourceIndex = sorted.findIndex(r => r.path === "/api/:resource");
+        console.assert(apiUsersIdIndex < apiResourceIndex, "/api/users/:id should come before /api/:resource");
+        console.log("  ✓ Static routes first, catch-all last, specific before general");
+    });
+    runTestGroup("sortRoutesByPriority - Mixed Syntaxes", () => {
+        const routes = [
+            { path: "/files/$", isStatic: false }, // TanStack splat
+            { path: "/blog/[slug]", isStatic: false }, // Next.js dynamic
+            { path: "/user/:id", isStatic: false }, // React Router dynamic
+            { path: "/about", isStatic: true },
+            { path: "/docs/[...path]", isStatic: false }, // Next.js catch-all
+            { path: "/product/@id", isStatic: false }, // Vike dynamic
+        ];
+        const sorted = sortRoutesByPriority(routes);
+        console.log("  Mixed syntax routes sorted:", sorted.map(r => r.path).join(", "));
+        // Static should be first
+        console.assert(sorted[0].path === "/about", "Static route should be first");
+        // Catch-all routes should be last
+        const catchAllPaths = ["/files/$", "/docs/[...path]"];
+        const lastTwo = sorted.slice(-2).map(r => r.path);
+        console.assert(catchAllPaths.every(p => lastTwo.includes(p)), "Catch-all routes should be last");
+        console.log("  ✓ Correctly handles mixed syntaxes including Vike @param");
+    });
+}
+// ============================================================================
+// addRegexToRoutes Tests
+// ============================================================================
+function testAddRegexToRoutes() {
+    runTestGroup("addRegexToRoutes", () => {
+        const routes = [
+            { path: "/", isStatic: true },
+            { path: "/about", isStatic: true },
+            { path: "/blog/:slug", isStatic: false },
+            { path: "/user/:id/posts", isStatic: false },
+        ];
+        const result = addRegexToRoutes(routes);
+        console.log("  Static routes should not have regex:");
+        console.assert(!result[0].regex, "/ should not have regex");
+        console.assert(!result[1].regex, "/about should not have regex");
+        console.log("    ✓ / and /about have no regex");
+        console.log("  Dynamic routes should have regex:");
+        console.assert(result[2].regex !== undefined, "/blog/:slug should have regex");
+        console.assert(result[3].regex !== undefined, "/user/:id/posts should have regex");
+        console.log(`    ✓ /blog/:slug → ${result[2].regex}`);
+        console.log(`    ✓ /user/:id/posts → ${result[3].regex}`);
+        // Verify regex actually works
+        if (result[2].regex) {
+            assertMatch(result[2].regex, "/blog/my-post", true);
+        }
+    });
+    runTestGroup("addRegexToRoutes - with srcRoute", () => {
+        const routes = [
+            { path: "/blog/my-post", isStatic: true, srcRoute: "/blog/:slug" },
+        ];
+        const result = addRegexToRoutes(routes);
+        console.assert(result[0].regex !== undefined, "Should use srcRoute for regex");
+        console.log(`  ✓ Uses srcRoute "/blog/:slug" → ${result[0].regex}`);
+    });
+}
+// ============================================================================
+// convertRoutesToMetaFormat Tests
+// ============================================================================
+function testConvertRoutesToMetaFormat() {
+    runTestGroup("convertRoutesToMetaFormat", () => {
+        const routes = [
+            { path: "/", isStatic: true },
+            { path: "/about", isStatic: true },
+            { path: "/blog/:slug", isStatic: false },
+            { path: "/files/*", isStatic: false },
+        ];
+        const result = convertRoutesToMetaFormat(routes);
+        console.log("  Static routes keep original path:");
+        console.assert(result[0].regexPath === "/", "/ should stay /");
+        console.assert(result[1].regexPath === "/about", "/about should stay /about");
+        console.log(`    ✓ "/" → "${result[0].regexPath}"`);
+        console.log(`    ✓ "/about" → "${result[1].regexPath}"`);
+        console.log("  Dynamic routes converted to regex:");
+        console.assert(result[2].regexPath.includes("([^/]+)"), "/blog/:slug should be regex");
+        console.assert(result[3].regexPath.includes("(.*)"), "/files/* should be regex");
+        console.log(`    ✓ "/blog/:slug" → "${result[2].regexPath}"`);
+        console.log(`    ✓ "/files/*" → "${result[3].regexPath}"`);
+        console.log("  isStatic preserved:");
+        console.assert(result[0].isStatic === true, "/ isStatic should be true");
+        console.assert(result[2].isStatic === false, "/blog/:slug isStatic should be false");
+        console.log("    ✓ isStatic values preserved");
+    });
+}
+// ============================================================================
+// Regression Tests
+// ============================================================================
+function testRegressions() {
+    runTestGroup("Regression Tests", () => {
+        // Issue: [[param]] was producing ([^/]+)? instead of (?:/([^/]+))?
+        console.log("  Issue: Optional bracket params with preceding slash");
+        const optBracket = routeToRegex("/blog/[[slug]]");
+        assertMatch(optBracket, "/blog", true, "Should match without param");
+        assertMatch(optBracket, "/blog/my-post", true, "Should match with param");
+        // Note: /blog/ with trailing slash but no param may not match - this is correct behavior
+        // Issue: Dollar splat $ not matching correctly
+        console.log("  Issue: Dollar splat handling");
+        const dollarSplat = routeToRegex("/api/$");
+        assertMatch(dollarSplat, "/api", true);
+        assertMatch(dollarSplat, "/api/", true);
+        assertMatch(dollarSplat, "/api/anything", true);
+        assertMatch(dollarSplat, "/api/nested/path", true);
+        // Issue: Bracket catch-all [...] behavior
+        console.log("  Issue: Bracket catch-all consistency");
+        const bracketCatchAll = routeToRegex("/docs/[...path]");
+        const bracketOptCatchAll = routeToRegex("/docs/[[...path]]");
+        // Both should have similar structure
+        console.log(`    [...path] → ${bracketCatchAll}`);
+        console.log(`    [[...path]] → ${bracketOptCatchAll}`);
+        assertMatch(bracketCatchAll, "/docs", true);
+        assertMatch(bracketOptCatchAll, "/docs", true);
+    });
+}
+// ============================================================================
+// Run All Tests
+// ============================================================================
+export function runAllTests() {
+    console.log("╔════════════════════════════════════════════════════════════╗");
+    console.log("║           Route Regex Test Suite                           ║");
+    console.log("╚════════════════════════════════════════════════════════════╝");
+    try {
+        testIsDynamicRoute();
+        testIsCatchAllRoute();
+        testColonSyntax();
+        testDollarSyntax();
+        testAtSyntax();
+        testBracketSyntax();
+        testOptions();
+        testEdgeCases();
+        testSortRoutes();
+        testAddRegexToRoutes();
+        testConvertRoutesToMetaFormat();
+        testRegressions();
+        console.log("\n╔════════════════════════════════════════════════════════════╗");
+        console.log("║  ✓ All tests passed!                                       ║");
+        console.log("╚════════════════════════════════════════════════════════════╝\n");
+    }
+    catch (error) {
+        console.error("\n╔════════════════════════════════════════════════════════════╗");
+        console.error("║  ✗ Tests failed!                                           ║");
+        console.error("╚════════════════════════════════════════════════════════════╝");
+        console.error(error);
+        process.exit(1);
+    }
+}
+// Run tests if executed directly
+runAllTests();
+//# sourceMappingURL=regex.test.js.map