ziko 0.50.2 → 0.51.1

package/src/math/random/index.js

@@ -1,8 +1,6 @@
 
-import{Complex}from"../complex/index.js"
 import { Utils } from "../utils/index.js";
-import{Base}from"../discret/index.js"
-import { matrix } from "../matrix/index.js";
+import{ Base } from "../discret/index.js"
 class Random {
     static float(a = 1, b) {
         return b ? Math.random() * (b - a) + a : a * Math.random();
@@ -45,10 +43,6 @@ class Random {
     static shuffleArr(arr){
         return arr.sort(()=>0.5-Math.random())    
     }
-    static shuffleMatrix(M){
-            const {rows,cols,arr}=M;
-            return matrix(rows,cols,arr.flat().sort(()=>0.5-Math.random()))
-    }
     static floats(n, a, b) {
         return new Array(n).fill(0).map(() => this.float(a, b));
     }
@@ -83,91 +77,93 @@ class Random {
     static colors(n) {
         return new Array(n).fill(null).map(()=>this.color());
     }
-    static complex(a = [0,1], b = [0,1]) {
-        return a instanceof Array?
-        new Complex(
-            this.float(a[0], a[1]),
-            this.float(b[0], b[1])
-        ):
-        new Complex(
-            ...this.floats(2,a,b)
-        )
+
+    // Should be Moved to Matrix and Complex to avoid Circular dependencies
+    // static complex(a = [0,1], b = [0,1]) {
+    //     return a instanceof Array?
+    //     new Complex(
+    //         this.float(a[0], a[1]),
+    //         this.float(b[0], b[1])
+    //     ):
+    //     new Complex(
+    //         ...this.floats(2,a,b)
+    //     )
         
-    }
-    static complexInt(a = [0,1], b = [0,1]) {
-        return new Complex(
-            this.int(a[0], a[1]),
-            this.int(b[0], b[1])
-            );
-    }
-    static complexBin() {
-        return new Complex(...this.bins(2));
-    }
-    static complexOct() {
-        return new Complex(...this.octs(2));
-    }
-    static complexDec() {
-        return new Complex(...this.decs(10));
-    }
-    static complexHex() {
-        return new Complex(...this.octs(2));
-    }
-    static complexes(n, a = 0, b = 1) {
-        return new Array(n).fill(0).map(() => this.complex(a, b));
-    }
-    static complexesInt(n, a = 0, b = 1) {
-        return new Array(n).fill(0).map(() => this.complexInt(a, b));
-    }
-    static complexesBin(n) {
-        return new Array(n).fill(0).map(() => this.complexBin());
-    }
-    static complexesOct(n) {
-        return new Array(n).fill(0).map(() => this.complexOct());
-    }
-    static complexesDec(n) {
-        return new Array(n).fill(0).map(() => this.complexDec());
-    }
-    static complexesHex(n) {
-        return new Array(n).fill(0).map(() => this.complexHex());
-    }
-    static matrix(r,c,min,max){
-        return matrix(r,c,this.floats(r*c,min,max))
-    }
-    static matrixInt(r,c,min,max){
-        return matrix(r,c,this.ints(r*c,min,max))
-    }
-    static matrixBin(r,c){
-        return matrix(r,c,this.bins(r*c))
-    }
-    static matrixOct(r,c){
-        return matrix(r,c,this.octs(r*c))
-    }
-    static matrixDec(r,c){
-        return matrix(r,c,this.decs(r*c))
-    }
-    static matrixHex(r,c){
-        return matrix(r,c,this.hex(r*c))
-    }
-    static matrixColor(r,c){
-        return matrix(r,c,this.colors(r*c))
-    }
-    static matrixComplex(r,c,a,b){
-        return matrix(r,c,this.complexes(r*c,a,b))
-    }
-    static matrixComplexInt(r,c,a,b){
-        return matrix(r,c,this.complexesInt(r*c,a,b))
-    }
-    static matrixComplexBin(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
-    static matrixComplexOct(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
-    static matrixComplexDec(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
-    static matrixComplexHex(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
+    // }
+    // static complexInt(a = [0,1], b = [0,1]) {
+    //     return new Complex(
+    //         this.int(a[0], a[1]),
+    //         this.int(b[0], b[1])
+    //         );
+    // }
+    // static complexBin() {
+    //     return new Complex(...this.bins(2));
+    // }
+    // static complexOct() {
+    //     return new Complex(...this.octs(2));
+    // }
+    // static complexDec() {
+    //     return new Complex(...this.decs(10));
+    // }
+    // static complexHex() {
+    //     return new Complex(...this.octs(2));
+    // }
+    // static complexes(n, a = 0, b = 1) {
+    //     return new Array(n).fill(0).map(() => this.complex(a, b));
+    // }
+    // static complexesInt(n, a = 0, b = 1) {
+    //     return new Array(n).fill(0).map(() => this.complexInt(a, b));
+    // }
+    // static complexesBin(n) {
+    //     return new Array(n).fill(0).map(() => this.complexBin());
+    // }
+    // static complexesOct(n) {
+    //     return new Array(n).fill(0).map(() => this.complexOct());
+    // }
+    // static complexesDec(n) {
+    //     return new Array(n).fill(0).map(() => this.complexDec());
+    // }
+    // static complexesHex(n) {
+    //     return new Array(n).fill(0).map(() => this.complexHex());
+    // }
+    // static matrix(r,c,min,max){
+    //     return matrix(r,c,this.floats(r*c,min,max))
+    // }
+    // static matrixInt(r,c,min,max){
+    //     return matrix(r,c,this.ints(r*c,min,max))
+    // }
+    // static matrixBin(r,c){
+    //     return matrix(r,c,this.bins(r*c))
+    // }
+    // static matrixOct(r,c){
+    //     return matrix(r,c,this.octs(r*c))
+    // }
+    // static matrixDec(r,c){
+    //     return matrix(r,c,this.decs(r*c))
+    // }
+    // static matrixHex(r,c){
+    //     return matrix(r,c,this.hex(r*c))
+    // }
+    // static matrixColor(r,c){
+    //     return matrix(r,c,this.colors(r*c))
+    // }
+    // static matrixComplex(r,c,a,b){
+    //     return matrix(r,c,this.complexes(r*c,a,b))
+    // }
+    // static matrixComplexInt(r,c,a,b){
+    //     return matrix(r,c,this.complexesInt(r*c,a,b))
+    // }
+    // static matrixComplexBin(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
+    // static matrixComplexOct(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
+    // static matrixComplexDec(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
+    // static matrixComplexHex(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
 }
 export{Random}

package/src/math/signal/functions.js

@@ -1,15 +1,13 @@
-import { Complex , complex } from "../complex/index.js";
 import { abs , pow , sqrtn , max , min} from "../functions/index.js";
 import { mul } from "../utils/index.js";
 import { E } from "../const.js";
-import { Matrix  } from "../matrix/Matrix.js";
 const zeros=(n)=>new Array(n).fill(0);
 const ones=(n)=>new Array(n).fill(1);
 const nums=(num,n)=>new Array(n).fill(num);
 const norm=(value, min, max)=>{
     if (typeof value === "number") return min !== max ? (value - min) / (max - min) : 0;
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, norm(value.arr.flat(1), min, max));
-    else if (value instanceof Complex) return new Complex(norm(value.a, min, max), norm(value.b, min, max));
+    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, norm(value.arr.flat(1), min, max));
+    else if (value.isComplex?.()) return new value.constructor(norm(value.a, min, max), norm(value.b, min, max));
     else if (value instanceof Array) {
         if (value.every((n) => typeof (n === "number"))) {
             return value.map((n) => norm(n, min, max));
@@ -23,8 +21,8 @@ const norm=(value, min, max)=>{
 }
 const lerp=(value, min, max)=>{
     if (typeof value === "number") return (max - min) * value + min;
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
-    else if (value instanceof Complex) return new Complex(lerp(value.a, min, max), lerp(value.b, min, max));
+    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
+    else if (value.isComplex?.()) return new value.constructor(lerp(value.a, min, max), lerp(value.b, min, max));
     else if (value instanceof Array) {
         if (value.every((n) => typeof (n === "number"))) {
             return value.map((n) => lerp(n, min, max));
@@ -36,17 +34,17 @@ const lerp=(value, min, max)=>{
         }
     }
 }
-const map=(value, a, b, c, d)=>{
-    if (typeof value === "number") return lerp(norm(value, a, b), c, d);
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, map(value.arr.flat(1), a, b, c, d));
-    else if (value instanceof Complex) return new Complex(map(value.a, b, c, d), map(value.b, a, b, c, d));
-    else if (value instanceof Array) {
-        if (value.every((n) => typeof (n === "number"))) {
-            return value.map((n) => map(n, a, b, c, d));
+const map=(x, a, b, c, d)=>{
+    if (typeof x === "number") return lerp(norm(x, a, b), c, d);
+    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, map(x.arr.flat(1), a, b, c, d));
+    else if (x.isComplex?.()) return new x.constructor(map(x.a, b, c, d), map(x.b, a, b, c, d));
+    else if (x instanceof Array) {
+        if (x.every((n) => typeof (n === "number"))) {
+            return x.map((n) => map(n, a, b, c, d));
         } else {
-            let y = new Array(value.length);
-            for (let i = 0; i < value.length; i++) {
-                y[i] = map(value[i], a, b, c, d);
+            let y = new Array(x.length);
+            for (let i = 0; i < x.length; i++) {
+                y[i] = map(x[i], a, b, c, d);
             }
         }
     }
@@ -54,8 +52,8 @@ const map=(value, a, b, c, d)=>{
 const clamp=(x, a , b)=>{
     const [min_value,max_value]=[min(a,b),max(a,b)]
     if (typeof x === "number") return min(max(x, min_value), max_value);
-    else if (x instanceof Matrix) return new Matrix(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
-    else if (x instanceof Complex) return new Complex(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
+    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
+    else if (x.isComplex?.()) return new x.constructor(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
     else if (x instanceof Array) {
         if (x.every((n) => typeof (n === "number"))) {
             return x.map((n) => clamp(n, min_value, max_value));
@@ -90,14 +88,14 @@ const linspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         return Y
     }
 
-    if([a,b].some(n=>n instanceof Complex)){
-        const z1=complex(a)
-        const z2=complex(b)
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a)
+        const z2 = new n.constructor(b)
         n=n||Math.abs(z1.a-z2.a)+1;
         const X=linspace(z1.a,z2.a,n,endpoint);
         const Y=linspace(z1.b,z2.b,n,endpoint);
         let Z=new Array(n).fill(null);
-        Z=Z.map((n,i)=>complex(X[i],Y[i]));
+        Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
         return Z;
     }
 }
@@ -117,9 +115,9 @@ const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         return a<b?Y:Y.reverse()
     }
 
-    if([a,b].some(n=>n instanceof Complex)){
-        const z1=complex(a)
-        const z2=complex(b)
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a)
+        const z2 = new n.constructor(b)
         n=n||Math.abs(z1.a-z2.a)+1;
         let base;
         endpoint ? base = sqrtn(z2.div(z1),n-1) : base = sqrtn(z2.div(z1),n) ;

package/src/math/utils/arithmetic.js

@@ -1,13 +1,11 @@
-import { Complex,complex} from "../complex/index.js";
-import { Matrix  } from "../matrix/index.js";
 const _add=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a + b;
-        else if (b instanceof Complex)return complex(a + b.a, b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).add(b);
+        else if (b.isComplex?.())return new b.constructor(a + b.a, b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).add(b);
         else if (b instanceof Array)return b.map(n=>add(n,a));                 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.add(n));
         return a.clone.add(b);
     }
@@ -23,11 +21,11 @@ const _add=(a,b)=>{
 const _sub=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a - b;
-        else if (b instanceof Complex)return complex(a - b.a, -b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
+        else if (b.isComplex?.())return new b.constructor(a - b.a, -b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).sub(b);
         else if (b instanceof Array)return b.map(n=>sub(n,a));                 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.sub(n));
         return a.clone.sub(b);
     }
@@ -45,11 +43,11 @@ const _sub=(a,b)=>{
 const _mul=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a * b;
-        else if (b instanceof Complex)return complex(a * b.a,a * b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
+        else if (b.isComplex?.())return new b.constructor(a * b.a,a * b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).mul(b);
         else if (b instanceof Array)return b.map(n=>mul(a,n)); 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.mul(n));
         return a.clone.mul(b);
     }
@@ -67,11 +65,11 @@ const _mul=(a,b)=>{
 const _div=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a / b;
-        else if (b instanceof Complex)return complex(a / b.a,a / b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
+        else if (b.isComplex?.())return new b.constructor(a / b.a,a / b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).div(b);
         else if (b instanceof Array)return b.map(n=>div(a,n));
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.div(n));
         return a.clone.div(b);
     }
@@ -89,11 +87,11 @@ const _div=(a,b)=>{
 const _modulo=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a % b;
-            else if (b instanceof Complex)return complex(a % b.a,a % b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
+            else if (b.isComplex?.())return new b.constructor(a % b.a,a % b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).modulo(b);
             else if (b instanceof Array)return b.map(n=>div(a,n));
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.div(n));
             return a.clone.div(b);
         }

package/src/math/utils/mapfun.js

@@ -1,9 +1,6 @@
-import { Matrix } from "../matrix/index.js";
-import { Complex , complex } from "../complex/index.js";
 import {ln,e,cos,sin,sqrt,cosh,sinh} from "../functions/index.js";
 import { Fixed } from "../functions/helper.js";
 // To generalise
-
 const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
         if(x===null) return fun(null);
@@ -12,10 +9,9 @@ const mapfun=(fun,...X)=>{
         if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
         if(x instanceof Set) return new Set(mapfun(fun,...[...x]));
         if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
-        if(x instanceof Matrix){
-            return new Matrix(x.rows,x.cols, mapfun(x.arr.flat(1)))
-        }
-        if(x instanceof Complex){
+        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
+        if(x.isComplex?.()){
+            const complex = (...args) => new x.constructor(...args) 
             const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
             switch(fun){
                 case Math.log: return complex(ln(z),phi); // Done

package/src/router/file-based-router/index.js

@@ -0,0 +1,46 @@
+import { 
+    get_root,
+    normalize_path,
+    routes_matcher,
+    is_dynamic,
+    dynamic_routes_parser
+ } from "../utils/index.js"
+export async function createSPAFileBasedRouter(
+  pages, 
+  target = globalThis?.document?.body
+) {
+  if(!(target instanceof HTMLElement) && target?.element instanceof HTMLElement) target = target?.element;
+  if (!(target instanceof HTMLElement)) {
+    throw new Error("Invalid mount target: must be HTMLElement or UIElement");
+  }
+  let path = decodeURIComponent(globalThis.location.pathname.replace(/\/$/, ''));
+  const routes = Object.keys(pages);
+  const root = get_root(routes);
+
+  const pairs = {};
+  for (const route of routes) {
+    const module = await pages[route]();
+    const modComponent = await module.default;
+    pairs[normalize_path(route, root)] = modComponent;
+  }
+
+  let mask = null;
+  let component = null;
+
+  for (const [routePath, comp] of Object.entries(pairs)) {
+    if (routes_matcher(routePath, `/${path}`)) {
+      mask = routePath;
+      component = comp;
+      break;
+    }
+  }
+
+  if (!mask) return; // no route matched
+
+  const params = is_dynamic(mask) ? dynamic_routes_parser(mask, path) : undefined;
+  const mounted = params ? await component(params) : await component();
+
+  if(mounted instanceof HTMLElement) target.append(mounted);
+  else mounted.mount(target);
+
+}

package/src/router/index.js

@@ -0,0 +1,2 @@
+export * from './file-based-router/index.js'
+export * from './utils/index.js'

package/src/router/utils/dynamic-routes-parser.js

@@ -0,0 +1,76 @@
+export function dynamic_routes_parser(mask, route) {
+  const maskSegments = mask.split("/").filter(Boolean);
+  const routeSegments = route.split("/").filter(Boolean);
+  const params = {};
+  let i = 0, j = 0;
+  while (i < maskSegments.length && j < routeSegments.length) {
+    const maskSegment = maskSegments[i];
+    const routeSegment = routeSegments[j];
+    if (maskSegment.startsWith("[...") && maskSegment.endsWith("]")) {
+      const paramName = maskSegment.slice(4, -1);
+      const remainingMaskSegments = maskSegments.length - i - 1;
+      if (remainingMaskSegments === 0) {
+        params[paramName] = routeSegments.slice(j).join("/");
+        break;
+      }
+      let requiredSegments = 0;
+      for (let k = i + 1; k < maskSegments.length; k++) {
+        if (!maskSegments[k].endsWith("]+")) requiredSegments++;
+      }
+      const remainingRouteSegments = routeSegments.length - j;
+      const segmentsToConsume = remainingRouteSegments - requiredSegments;
+      if (segmentsToConsume >= 1) {
+        params[paramName] = routeSegments
+          .slice(j, j + segmentsToConsume)
+          .join("/");
+        j += segmentsToConsume;
+      } 
+      else return {};
+      i++;
+      continue;
+    }
+    if (maskSegment.startsWith("[") && maskSegment.endsWith("]+")) {
+      const paramName = maskSegment.slice(1, -2);
+      if (routeSegment) {
+        params[paramName] = routeSegment;
+        j++;
+      }
+      i++;
+      continue;
+    }
+    if (maskSegment.startsWith("[") && maskSegment.endsWith("]")) {
+      const paramName = maskSegment.slice(1, -1);
+      params[paramName] = routeSegment;
+    } 
+    else if (maskSegment !== routeSegment) return {};
+    i++;
+    j++;
+  }
+  return params;
+}
+
+
+// console.log("\n=== PARSER TESTS ===");
+// console.log(dynamic_routes_parser("/user/[id]+", "/user"));
+// // 👉 {}
+
+// console.log(dynamic_routes_parser("/user/[id]+", "/user/42"));
+// // 👉 { id: "42" }
+
+// console.log(dynamic_routes_parser("/blog/[...slug]", "/blog/2025/oct/post"));
+// // 👉 { slug: "2025/oct/post" }
+
+// console.log(
+//   dynamic_routes_parser("/product/[category]/[id]+", "/product/electronics"),
+// );
+// // 👉 { category: "electronics" }
+
+// console.log("\n=== FIX TEST ===");
+// console.log(dynamic_routes_parser("/[...slug]/[id]", "/sl1/sl2/9"));
+// // 👉 { slug: "sl1/sl2", id: "9" }
+
+// console.log(dynamic_routes_parser("/[slug]/[...id]", "/sl1/id1/id2"));
+// // 👉 { slug: "sl1", id: "id1/id2" }
+
+// console.log(dynamic_routes_parser("/blog/lang/[lang]/id/[id]", "/blog/lang/en/id/10"));
+// // 👉 { lang: "en", id: "10" }

package/src/router/utils/get-root.js

@@ -0,0 +1,16 @@
+export function get_root(paths) {
+   if (paths.length === 0) return '';
+   const splitPaths = paths.map(path => path.split('/'));
+   const minLength = Math.min(...splitPaths.map(parts => parts.length));
+   let commonParts = [];
+   for (let i = 0; i < minLength; i++) {
+       const part = splitPaths[0][i]; 
+       if (splitPaths.every(parts => parts[i] === part || parts[i].startsWith('['))) {
+           commonParts.push(part);
+       } 
+       else break; 
+       
+   }
+   const root = commonParts.join('/') + (commonParts.length ? '/' : '');
+   return root;
+}

package/src/router/utils/index.js

@@ -0,0 +1,5 @@
+export * from './normalize-path.js'
+export * from './routes-matcher.js'
+export * from './routes-grouper.js'
+export * from './dynamic-routes-parser.js'
+export * from './get-root.js'

package/src/router/utils/normalize-path.js

@@ -0,0 +1,17 @@
+export function normalize_path(inputPath, root = './src/pages', extensions = ['js', 'ts']) {
+    if(root.at(-1)==="/") root = root.slice(0, -1)
+    const normalizedPath = inputPath.replace(/\\/g, '/')
+                                    // .replace(/\[(\w+)\]/g, '$1/:$1');
+    const parts = normalizedPath.split('/');
+    const rootParts = root.split('/');
+    const rootIndex = parts.indexOf(rootParts[rootParts.length - 1]);
+    if (rootIndex !== -1) {
+        const subsequentParts = parts.slice(rootIndex + 1);
+        const lastPart = subsequentParts[subsequentParts.length - 1];
+        const isIndexFile = lastPart === 'index.js' || lastPart === 'index.ts';
+        const hasValidExtension = extensions.some(ext => lastPart === `.${ext}` || lastPart.endsWith(`.${ext}`));
+        if (isIndexFile) return '/' + (subsequentParts.length > 1 ? subsequentParts.slice(0, -1).join('/') : '');
+        if (hasValidExtension) return '/' + subsequentParts.join('/').replace(/\.(js|ts)$/, '');
+    }
+    return '';
+ }

package/src/router/utils/routes-grouper.js

@@ -0,0 +1,22 @@
+export function is_dynamic(path) {
+  const DynamicPattern = /(:\w+|\[\.\.\.\w+\]|\[\w+\]\+?)/;
+  return DynamicPattern.test(path);
+}
+export function routes_grouper(routeMap) {
+  const grouped = {
+    static: {},
+    dynamic: {},
+  };
+  for (const [path, value] of Object.entries(routeMap)) {
+    if (is_dynamic(path)) {
+      const segments = path.split("/").filter(Boolean);
+      const optionalIndex = segments.findIndex(seg => seg.endsWith("]+"));
+      const hasInvalidOptional =
+        optionalIndex !== -1 && optionalIndex !== segments.length - 1;
+      if (hasInvalidOptional) throw new Error(`Invalid optional param position in route: "${path}" — optional parameters can only appear at the end.`);
+      grouped.dynamic[path] = value;
+    } 
+    else grouped.static[path] = value;
+  }
+  return grouped;
+}

package/src/router/utils/routes-matcher.js

@@ -0,0 +1,60 @@
+export function routes_matcher(mask, route) {
+  const maskSegments = mask.split("/").filter(Boolean);
+  const routeSegments = route.split("/").filter(Boolean);
+  let i = 0, j = 0;
+  while (i < maskSegments.length && j < routeSegments.length) {
+    const maskSegment = maskSegments[i];
+    const routeSegment = routeSegments[j];
+    if (maskSegment.startsWith("[...") && maskSegment.endsWith("]")) {
+      const remainingMaskSegments = maskSegments.length - i - 1;
+      if (remainingMaskSegments === 0) return true;
+      // Calculate minimum required route segments for remaining mask
+      let requiredSegments = 0;
+      for (let k = i + 1; k < maskSegments.length; k++) {
+        if (!maskSegments[k].endsWith("]+")) {
+          requiredSegments++;
+        }
+      }
+      const remainingRouteSegments = routeSegments.length - j;
+      if (remainingRouteSegments < requiredSegments) return false;
+      const segmentsToConsume = remainingRouteSegments - requiredSegments;
+      if (segmentsToConsume < 1) return false;
+      j += segmentsToConsume;
+      i++;
+      continue;
+    }
+    if (maskSegment.startsWith("[") && maskSegment.endsWith("]+")) {
+      if (routeSegment) j++;
+      i++;
+      continue;
+    }
+    if (maskSegment.startsWith("[") && maskSegment.endsWith("]")) {
+      i++;
+      j++;
+      continue;
+    }
+    if (maskSegment !== routeSegment) return false;
+    i++;
+    j++;
+  }
+  while (i < maskSegments.length) {
+    const seg = maskSegments[i];
+    if (seg.endsWith("]+")) {
+      i++;
+      continue;
+    }
+    return false;
+  }
+  return i === maskSegments.length && j === routeSegments.length;
+}
+
+
+// // DEMO
+// console.log("=== EXISTING TESTS ===");
+// console.log(routes_matcher("/user/[id]+", "/user")); // true
+// console.log(routes_matcher("/user/[id]+", "/user/42")); // true
+// console.log(routes_matcher("/blog/[...slug]", "/blog/a/b")); // true
+// console.log(routes_matcher("/blog/[id]", "/blog")); // false
+// console.log(routes_matcher("/product/:id", "/product/99")); // true
+
+