one 1.1.538 → 1.1.539

package/dist/cjs/fork/__tests__/getStateFromPath.test.native.js

@@ -1,129 +1,128 @@
 "use strict";
-var import_vitest = require("vitest"), import_immer = require("immer"), import_findFocusedRoute = require("../findFocusedRoute"), import_getPathFromState = require("../getPathFromState"), import_getStateFromPath = require("../getStateFromPath"), changePath = function(state, path) {
-  return (0, import_immer.produce)(state, function(draftState) {
-    var route = (0, import_findFocusedRoute.findFocusedRoute)(draftState);
-    route.path = path;
-  });
-};
-(0, import_vitest.test)("returns undefined for invalid path", function() {
+
+var import_vitest = require("vitest"),
+  import_immer = require("immer"),
+  import_findFocusedRoute = require("../findFocusedRoute.native.js"),
+  import_getPathFromState = require("../getPathFromState.native.js"),
+  import_getStateFromPath = require("../getStateFromPath.native.js"),
+  changePath = function (state, path) {
+    return (0, import_immer.produce)(state, function (draftState) {
+      var route = (0, import_findFocusedRoute.findFocusedRoute)(draftState);
+      route.path = path;
+    });
+  };
+(0, import_vitest.test)("returns undefined for invalid path", function () {
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("//")).toBeUndefined();
 });
-import_vitest.test.skip("converts path string to initial state", function() {
-  var path = "foo/bar/baz%20qux?author=jane%20%26%20co&valid=true", state = {
-    routes: [
-      {
+import_vitest.test.skip("converts path string to initial state", function () {
+  var path = "foo/bar/baz%20qux?author=jane%20%26%20co&valid=true",
+    state = {
+      routes: [{
         name: "foo",
         state: {
-          routes: [
-            {
-              name: "bar",
-              state: {
-                routes: [
-                  {
-                    name: "baz qux",
-                    params: {
-                      author: "jane & co",
-                      valid: "true"
-                    },
-                    path
-                  }
-                ]
-              }
+          routes: [{
+            name: "bar",
+            state: {
+              routes: [{
+                name: "baz qux",
+                params: {
+                  author: "jane & co",
+                  valid: "true"
+                },
+                path
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state))).toEqual(changePath(state, "/foo/bar/baz%20qux?author=jane%20%26%20co&valid=true"));
 });
-import_vitest.test.skip("decodes encoded params in path", function() {
-  var path = "/foo/bar/bar_%23_foo", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Bar: {
-            path: "/bar/:id"
+import_vitest.test.skip("decodes encoded params in path", function () {
+  var path = "/foo/bar/bar_%23_foo",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Bar: {
+              path: "/bar/:id"
+            }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                id: "bar_#_foo"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Bar",
+            params: {
+              id: "bar_#_foo"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)(path, config), config)).toEqual(path);
 });
-import_vitest.test.skip("decodes encoded params in path that have encoded /", function() {
-  var path = "/foo/bar/bar_%2F_foo", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Bar: {
-            path: "/bar/:id"
+import_vitest.test.skip("decodes encoded params in path that have encoded /", function () {
+  var path = "/foo/bar/bar_%2F_foo",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Bar: {
+              path: "/bar/:id"
+            }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                id: "bar_/_foo"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Bar",
+            params: {
+              id: "bar_/_foo"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)(path, config), config)).toEqual(path);
 });
-import_vitest.test.skip("converts path string to initial state with config", function() {
-  var path = "/foo/bar/sweet/apple/baz/jane?count=10&answer=42&valid=true", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Bar: {
-            path: "bar/:type/:fruit",
-            screens: {
-              Baz: {
-                path: "baz/:author",
-                parse: {
-                  author: function(author) {
-                    return author.replace(/^\w/, function(c) {
-                      return c.toUpperCase();
-                    });
+import_vitest.test.skip("converts path string to initial state with config", function () {
+  var path = "/foo/bar/sweet/apple/baz/jane?count=10&answer=42&valid=true",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Bar: {
+              path: "bar/:type/:fruit",
+              screens: {
+                Baz: {
+                  path: "baz/:author",
+                  parse: {
+                    author: function (author) {
+                      return author.replace(/^\w/, function (c) {
+                        return c.toUpperCase();
+                      });
+                    },
+                    count: Number,
+                    valid: Boolean
                   },
-                  count: Number,
-                  valid: Boolean
-                },
-                stringify: {
-                  author: function(author) {
-                    return author.toLowerCase();
+                  stringify: {
+                    author: function (author) {
+                      return author.toLowerCase();
+                    }
                   }
                 }
               }
@@ -131,128 +130,113 @@ import_vitest.test.skip("converts path string to initial state with config", fun
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                fruit: "apple",
-                type: "sweet"
-              },
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    params: {
-                      author: "Jane",
-                      count: 10,
-                      answer: "42",
-                      valid: !0
-                    },
-                    path
-                  }
-                ]
-              }
+          routes: [{
+            name: "Bar",
+            params: {
+              fruit: "apple",
+              type: "sweet"
+            },
+            state: {
+              routes: [{
+                name: "Baz",
+                params: {
+                  author: "Jane",
+                  count: 10,
+                  answer: "42",
+                  valid: !0
+                },
+                path
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles leading slash when converting", function() {
+(0, import_vitest.test)("handles leading slash when converting", function () {
   var path = "/foo/bar/?count=42";
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path)).toEqual({
-    routes: [
-      {
-        name: "foo",
-        state: {
-          routes: [
-            {
-              name: "bar",
-              params: {
-                count: "42"
-              },
-              path
-            }
-          ]
-        }
+    routes: [{
+      name: "foo",
+      state: {
+        routes: [{
+          name: "bar",
+          params: {
+            count: "42"
+          },
+          path
+        }]
       }
-    ]
+    }]
   });
 });
-(0, import_vitest.test)("handles ending slash when converting", function() {
+(0, import_vitest.test)("handles ending slash when converting", function () {
   var path = "foo/bar/?count=42";
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path)).toEqual({
-    routes: [
-      {
-        name: "foo",
-        state: {
-          routes: [
-            {
-              name: "bar",
-              params: {
-                count: "42"
-              },
-              path
-            }
-          ]
-        }
+    routes: [{
+      name: "foo",
+      state: {
+        routes: [{
+          name: "bar",
+          params: {
+            count: "42"
+          },
+          path
+        }]
       }
-    ]
+    }]
   });
 });
-(0, import_vitest.test)("handles route without param", function() {
-  var path = "foo/bar", state = {
-    routes: [
-      {
+(0, import_vitest.test)("handles route without param", function () {
+  var path = "foo/bar",
+    state = {
+      routes: [{
         name: "foo",
         state: {
-          routes: [
-            {
-              name: "bar",
-              path
-            }
-          ]
+          routes: [{
+            name: "bar",
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state))).toEqual(changePath(state, "/foo/bar"));
 });
-import_vitest.test.skip("converts path string to initial state with config with nested screens", function() {
-  var path = "/foe/bar/sweet/apple/baz/jane?count=10&answer=42&valid=true", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: {
-            path: "foe",
-            exact: !0,
-            screens: {
-              Bar: {
-                path: "bar/:type/:fruit",
-                screens: {
-                  Baz: {
-                    path: "baz/:author",
-                    parse: {
-                      author: function(author) {
-                        return author.replace(/^\w/, function(c) {
-                          return c.toUpperCase();
-                        });
+import_vitest.test.skip("converts path string to initial state with config with nested screens", function () {
+  var path = "/foe/bar/sweet/apple/baz/jane?count=10&answer=42&valid=true",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Foe: {
+              path: "foe",
+              exact: !0,
+              screens: {
+                Bar: {
+                  path: "bar/:type/:fruit",
+                  screens: {
+                    Baz: {
+                      path: "baz/:author",
+                      parse: {
+                        author: function (author) {
+                          return author.replace(/^\w/, function (c) {
+                            return c.toUpperCase();
+                          });
+                        },
+                        count: Number,
+                        valid: Boolean
                       },
-                      count: Number,
-                      valid: Boolean
-                    },
-                    stringify: {
-                      author: function(author) {
-                        return author.toLowerCase();
+                      stringify: {
+                        author: function (author) {
+                          return author.toLowerCase();
+                        }
                       }
                     }
                   }
@@ -262,140 +246,130 @@ import_vitest.test.skip("converts path string to initial state with config with
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Foe",
-              state: {
-                routes: [
-                  {
-                    name: "Bar",
+          routes: [{
+            name: "Foe",
+            state: {
+              routes: [{
+                name: "Bar",
+                params: {
+                  fruit: "apple",
+                  type: "sweet"
+                },
+                state: {
+                  routes: [{
+                    name: "Baz",
                     params: {
-                      fruit: "apple",
-                      type: "sweet"
+                      author: "Jane",
+                      count: 10,
+                      answer: "42",
+                      valid: !0
                     },
-                    state: {
-                      routes: [
-                        {
-                          name: "Baz",
-                          params: {
-                            author: "Jane",
-                            count: 10,
-                            answer: "42",
-                            valid: !0
-                          },
-                          path
-                        }
-                      ]
-                    }
-                  }
-                ]
-              }
+                    path
+                  }]
+                }
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("converts path string to initial state with config with nested screens and unused parse functions", function() {
-  var path = "/foe/baz/jane?count=10&answer=42&valid=true", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: {
-            path: "foe",
-            exact: !0,
-            screens: {
-              Baz: {
-                path: "baz/:author",
-                parse: {
-                  author: function(author) {
-                    return author.replace(/^\w/, function(c) {
-                      return c.toUpperCase();
-                    });
-                  },
-                  count: Number,
-                  valid: Boolean,
-                  id: Boolean
+import_vitest.test.skip("converts path string to initial state with config with nested screens and unused parse functions", function () {
+  var path = "/foe/baz/jane?count=10&answer=42&valid=true",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Foe: {
+              path: "foe",
+              exact: !0,
+              screens: {
+                Baz: {
+                  path: "baz/:author",
+                  parse: {
+                    author: function (author) {
+                      return author.replace(/^\w/, function (c) {
+                        return c.toUpperCase();
+                      });
+                    },
+                    count: Number,
+                    valid: Boolean,
+                    id: Boolean
+                  }
                 }
               }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Foe",
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    params: {
-                      author: "Jane",
-                      count: 10,
-                      answer: "42",
-                      valid: !0
-                    },
-                    path
-                  }
-                ]
-              }
+          routes: [{
+            name: "Foe",
+            state: {
+              routes: [{
+                name: "Baz",
+                params: {
+                  author: "Jane",
+                  count: 10,
+                  answer: "42",
+                  valid: !0
+                },
+                path
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/foe/baz/Jane?count=10&answer=42&valid=true"));
 });
-import_vitest.test.skip("handles nested object with unused configs and with parse in it", function() {
-  var path = "/bar/sweet/apple/foe/bis/jane?count=10&answer=42&valid=true", config = {
-    screens: {
-      Bar: {
-        path: "bar/:type/:fruit",
-        screens: {
-          Foo: {
-            screens: {
-              Foe: {
-                path: "foe",
-                screens: {
-                  Baz: {
-                    screens: {
-                      Bos: {
-                        path: "bos",
-                        exact: !0
-                      },
-                      Bis: {
-                        path: "bis/:author",
-                        stringify: {
-                          author: function(author) {
-                            return author.replace(/^\w/, function(c) {
-                              return c.toLowerCase();
-                            });
-                          }
+import_vitest.test.skip("handles nested object with unused configs and with parse in it", function () {
+  var path = "/bar/sweet/apple/foe/bis/jane?count=10&answer=42&valid=true",
+    config = {
+      screens: {
+        Bar: {
+          path: "bar/:type/:fruit",
+          screens: {
+            Foo: {
+              screens: {
+                Foe: {
+                  path: "foe",
+                  screens: {
+                    Baz: {
+                      screens: {
+                        Bos: {
+                          path: "bos",
+                          exact: !0
                         },
-                        parse: {
-                          author: function(author) {
-                            return author.replace(/^\w/, function(c) {
-                              return c.toUpperCase();
-                            });
+                        Bis: {
+                          path: "bis/:author",
+                          stringify: {
+                            author: function (author) {
+                              return author.replace(/^\w/, function (c) {
+                                return c.toLowerCase();
+                              });
+                            }
                           },
-                          count: Number,
-                          valid: Boolean
+                          parse: {
+                            author: function (author) {
+                              return author.replace(/^\w/, function (c) {
+                                return c.toUpperCase();
+                              });
+                            },
+                            count: Number,
+                            valid: Boolean
+                          }
                         }
                       }
                     }
@@ -406,342 +380,310 @@ import_vitest.test.skip("handles nested object with unused configs and with pars
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Bar",
         params: {
           fruit: "apple",
           type: "sweet"
         },
         state: {
-          routes: [
-            {
-              name: "Foo",
-              state: {
-                routes: [
-                  {
-                    name: "Foe",
+          routes: [{
+            name: "Foo",
+            state: {
+              routes: [{
+                name: "Foe",
+                state: {
+                  routes: [{
+                    name: "Baz",
                     state: {
-                      routes: [
-                        {
-                          name: "Baz",
-                          state: {
-                            routes: [
-                              {
-                                name: "Bis",
-                                params: {
-                                  author: "Jane",
-                                  count: 10,
-                                  answer: "42",
-                                  valid: !0
-                                },
-                                path
-                              }
-                            ]
-                          }
-                        }
-                      ]
+                      routes: [{
+                        name: "Bis",
+                        params: {
+                          author: "Jane",
+                          count: 10,
+                          answer: "42",
+                          valid: !0
+                        },
+                        path
+                      }]
                     }
-                  }
-                ]
-              }
+                  }]
+                }
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles parse in nested object for second route depth", function() {
-  var path = "/baz", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: {
-            path: "foe",
-            exact: !0
-          },
-          Bar: {
-            path: "bar",
-            exact: !0,
-            screens: {
-              Baz: {
-                path: "baz",
-                exact: !0
+(0, import_vitest.test)("handles parse in nested object for second route depth", function () {
+  var path = "/baz",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Foe: {
+              path: "foe",
+              exact: !0
+            },
+            Bar: {
+              path: "bar",
+              exact: !0,
+              screens: {
+                Baz: {
+                  path: "baz",
+                  exact: !0
+                }
               }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Baz",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles parse in nested object for second route depth and and path and parse in roots", function() {
-  var path = "/baz", config = {
-    screens: {
-      Foo: {
-        path: "foo/:id",
-        parse: {
-          id: Number
-        },
-        stringify: {
-          id: function(id) {
-            return `id=${id}`;
-          }
-        },
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: {
-                path: "baz",
-                exact: !0
+(0, import_vitest.test)("handles parse in nested object for second route depth and and path and parse in roots", function () {
+  var path = "/baz",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo/:id",
+          parse: {
+            id: Number
+          },
+          stringify: {
+            id: function (id) {
+              return `id=${id}`;
+            }
+          },
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Baz: {
+                  path: "baz",
+                  exact: !0
+                }
               }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Baz",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles path at top level", function() {
-  var path = "/foo/fruits/apple", config = {
-    path: "foo",
-    screens: {
-      Foo: {
-        screens: {
-          Fruits: "fruits/:fruit"
+import_vitest.test.skip("handles path at top level", function () {
+  var path = "/foo/fruits/apple",
+    config = {
+      path: "foo",
+      screens: {
+        Foo: {
+          screens: {
+            Fruits: "fruits/:fruit"
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Fruits",
-              params: {
-                fruit: "apple"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Fruits",
+            params: {
+              fruit: "apple"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles initialRouteName at top level", function() {
-  var path = "/baz", config = {
-    initialRouteName: "Boo",
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
+(0, import_vitest.test)("handles initialRouteName at top level", function () {
+  var path = "/baz",
+    config = {
+      initialRouteName: "Boo",
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    index: 1,
-    routes: [
-      {
+    },
+    state = {
+      index: 1,
+      routes: [{
         name: "Boo"
-      },
-      {
+      }, {
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Baz",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles initialRouteName inside a screen", function() {
-  var path = "/baz", config = {
-    screens: {
-      Foo: {
-        initialRouteName: "Foe",
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
+(0, import_vitest.test)("handles initialRouteName inside a screen", function () {
+  var path = "/baz",
+    config = {
+      screens: {
+        Foo: {
+          initialRouteName: "Foe",
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foe"
-            },
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Foe"
+          }, {
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Baz",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles initialRouteName included in path", function() {
-  var path = "/baz", config = {
-    screens: {
-      Foo: {
-        initialRouteName: "Foe",
-        screens: {
-          Foe: {
-            screens: {
-              Baz: "baz"
-            }
-          },
-          Bar: "bar"
+(0, import_vitest.test)("handles initialRouteName included in path", function () {
+  var path = "/baz",
+    config = {
+      screens: {
+        Foo: {
+          initialRouteName: "Foe",
+          screens: {
+            Foe: {
+              screens: {
+                Baz: "baz"
+              }
+            },
+            Bar: "bar"
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Foe",
-              state: {
-                routes: [
-                  {
-                    name: "Baz",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Foe",
+            state: {
+              routes: [{
+                name: "Baz",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles two initialRouteNames", function() {
-  var path = "/bar/sweet/apple/foe/bis/jane?answer=42&count=10&valid=true", config = {
-    screens: {
-      Bar: {
-        path: "bar/:type/:fruit",
-        screens: {
-          Foo: {
-            screens: {
-              Foe: {
-                path: "foe",
-                screens: {
-                  Baz: {
-                    initialRouteName: "Bos",
-                    screens: {
-                      Bos: {
-                        path: "bos",
-                        exact: !0
-                      },
-                      Bis: {
-                        path: "bis/:author",
-                        stringify: {
-                          author: function(author) {
-                            return author.replace(/^\w/, function(c) {
-                              return c.toLowerCase();
-                            });
-                          }
+import_vitest.test.skip("handles two initialRouteNames", function () {
+  var path = "/bar/sweet/apple/foe/bis/jane?answer=42&count=10&valid=true",
+    config = {
+      screens: {
+        Bar: {
+          path: "bar/:type/:fruit",
+          screens: {
+            Foo: {
+              screens: {
+                Foe: {
+                  path: "foe",
+                  screens: {
+                    Baz: {
+                      initialRouteName: "Bos",
+                      screens: {
+                        Bos: {
+                          path: "bos",
+                          exact: !0
                         },
-                        parse: {
-                          author: function(author) {
-                            return author.replace(/^\w/, function(c) {
-                              return c.toUpperCase();
-                            });
+                        Bis: {
+                          path: "bis/:author",
+                          stringify: {
+                            author: function (author) {
+                              return author.replace(/^\w/, function (c) {
+                                return c.toLowerCase();
+                              });
+                            }
                           },
-                          count: Number,
-                          valid: Boolean
+                          parse: {
+                            author: function (author) {
+                              return author.replace(/^\w/, function (c) {
+                                return c.toUpperCase();
+                              });
+                            },
+                            count: Number,
+                            valid: Boolean
+                          }
                         }
                       }
                     }
@@ -752,94 +694,85 @@ import_vitest.test.skip("handles two initialRouteNames", function() {
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Bar",
         params: {
           fruit: "apple",
           type: "sweet"
         },
         state: {
-          routes: [
-            {
-              name: "Foo",
-              state: {
-                routes: [
-                  {
-                    name: "Foe",
+          routes: [{
+            name: "Foo",
+            state: {
+              routes: [{
+                name: "Foe",
+                state: {
+                  routes: [{
+                    name: "Baz",
                     state: {
-                      routes: [
-                        {
-                          name: "Baz",
-                          state: {
-                            index: 1,
-                            routes: [
-                              {
-                                name: "Bos"
-                              },
-                              {
-                                name: "Bis",
-                                params: {
-                                  answer: "42",
-                                  author: "Jane",
-                                  count: 10,
-                                  valid: !0
-                                },
-                                path
-                              }
-                            ]
-                          }
-                        }
-                      ]
+                      index: 1,
+                      routes: [{
+                        name: "Bos"
+                      }, {
+                        name: "Bis",
+                        params: {
+                          answer: "42",
+                          author: "Jane",
+                          count: 10,
+                          valid: !0
+                        },
+                        path
+                      }]
                     }
-                  }
-                ]
-              }
+                  }]
+                }
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("accepts initialRouteName without config for it", function() {
-  var path = "/bar/sweet/apple/foe/bis/jane?answer=42&count=10&valid=true", config = {
-    screens: {
-      Bar: {
-        path: "bar/:type/:fruit",
-        screens: {
-          Foo: {
-            screens: {
-              Foe: {
-                path: "foe",
-                screens: {
-                  Baz: {
-                    initialRouteName: "Bas",
-                    screens: {
-                      Bos: {
-                        path: "bos",
-                        exact: !0
-                      },
-                      Bis: {
-                        path: "bis/:author",
-                        stringify: {
-                          author: function(author) {
-                            return author.replace(/^\w/, function(c) {
-                              return c.toLowerCase();
-                            });
-                          }
+import_vitest.test.skip("accepts initialRouteName without config for it", function () {
+  var path = "/bar/sweet/apple/foe/bis/jane?answer=42&count=10&valid=true",
+    config = {
+      screens: {
+        Bar: {
+          path: "bar/:type/:fruit",
+          screens: {
+            Foo: {
+              screens: {
+                Foe: {
+                  path: "foe",
+                  screens: {
+                    Baz: {
+                      initialRouteName: "Bas",
+                      screens: {
+                        Bos: {
+                          path: "bos",
+                          exact: !0
                         },
-                        parse: {
-                          author: function(author) {
-                            return author.replace(/^\w/, function(c) {
-                              return c.toUpperCase();
-                            });
+                        Bis: {
+                          path: "bis/:author",
+                          stringify: {
+                            author: function (author) {
+                              return author.replace(/^\w/, function (c) {
+                                return c.toLowerCase();
+                              });
+                            }
                           },
-                          count: Number,
-                          valid: Boolean
+                          parse: {
+                            author: function (author) {
+                              return author.replace(/^\w/, function (c) {
+                                return c.toUpperCase();
+                              });
+                            },
+                            count: Number,
+                            valid: Boolean
+                          }
                         }
                       }
                     }
@@ -850,1462 +783,1366 @@ import_vitest.test.skip("accepts initialRouteName without config for it", functi
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Bar",
         params: {
           fruit: "apple",
           type: "sweet"
         },
         state: {
-          routes: [
-            {
-              name: "Foo",
-              state: {
-                routes: [
-                  {
-                    name: "Foe",
+          routes: [{
+            name: "Foo",
+            state: {
+              routes: [{
+                name: "Foe",
+                state: {
+                  routes: [{
+                    name: "Baz",
                     state: {
-                      routes: [
-                        {
-                          name: "Baz",
-                          state: {
-                            index: 1,
-                            routes: [
-                              {
-                                name: "Bas"
-                              },
-                              {
-                                name: "Bis",
-                                params: {
-                                  answer: "42",
-                                  author: "Jane",
-                                  count: 10,
-                                  valid: !0
-                                },
-                                path
-                              }
-                            ]
-                          }
-                        }
-                      ]
+                      index: 1,
+                      routes: [{
+                        name: "Bas"
+                      }, {
+                        name: "Bis",
+                        params: {
+                          answer: "42",
+                          author: "Jane",
+                          count: 10,
+                          valid: !0
+                        },
+                        path
+                      }]
                     }
-                  }
-                ]
-              }
+                  }]
+                }
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("returns undefined if no matching screen is present (top level path)", function() {
-  var path = "/foo/bar", config = {
-    path: "qux",
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foo",
-          Bar: {
-            screens: {
-              Baz: "bar"
+(0, import_vitest.test)("returns undefined if no matching screen is present (top level path)", function () {
+  var path = "/foo/bar",
+    config = {
+      path: "qux",
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foo",
+            Bar: {
+              screens: {
+                Baz: "bar"
+              }
             }
           }
         }
       }
-    }
-  };
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toBeUndefined();
 });
-(0, import_vitest.test)("returns undefined if no matching screen is present", function() {
-  var path = "/baz", config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
+(0, import_vitest.test)("returns undefined if no matching screen is present", function () {
+  var path = "/baz",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo",
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  };
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toBeUndefined();
 });
-(0, import_vitest.test)("returns undefined if path is empty and no matching screen is present", function() {
-  var path = "", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
+(0, import_vitest.test)("returns undefined if path is empty and no matching screen is present", function () {
+  var path = "",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  };
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toBeUndefined();
 });
-import_vitest.test.skip("returns matching screen if path is empty", function() {
-  var path = "", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Qux: "",
-              Baz: "baz"
+import_vitest.test.skip("returns matching screen if path is empty", function () {
+  var path = "",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Qux: "",
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Qux",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Qux",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, ""));
 });
-import_vitest.test.skip("returns matching screen if path is only slash", function() {
-  var path = "/", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Qux: "",
-              Baz: "baz"
+import_vitest.test.skip("returns matching screen if path is only slash", function () {
+  var path = "/",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Qux: "",
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Qux",
-                    path: ""
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Qux",
+                path: ""
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, ""));
 });
-(0, import_vitest.test)("returns matching screen with params if path is empty", function() {
-  var path = "?foo=42", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Qux: {
-                path: "",
-                parse: {
-                  foo: Number
-                }
-              },
-              Baz: "baz"
+(0, import_vitest.test)("returns matching screen with params if path is empty", function () {
+  var path = "?foo=42",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foe",
+            Bar: {
+              screens: {
+                Qux: {
+                  path: "",
+                  parse: {
+                    foo: Number
+                  }
+                },
+                Baz: "baz"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "Qux",
-                    params: {
-                      foo: 42
-                    },
-                    path
-                  }
-                ]
-              }
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "Qux",
+                params: {
+                  foo: 42
+                },
+                path
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/?foo=42"));
 });
-(0, import_vitest.test)("doesn't match nested screen if path is empty", function() {
+(0, import_vitest.test)("doesn't match nested screen if path is empty", function () {
   var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            path: "bar",
-            screens: {
-              Qux: {
-                path: "",
-                parse: {
-                  foo: Number
+      screens: {
+        Foo: {
+          screens: {
+            Foe: "foe",
+            Bar: {
+              path: "bar",
+              screens: {
+                Qux: {
+                  path: "",
+                  parse: {
+                    foo: Number
+                  }
                 }
               }
             }
           }
         }
       }
-    }
-  }, path = "";
+    },
+    path = "";
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toBeUndefined();
 });
-import_vitest.test.skip("chooses more exhaustive pattern", function() {
-  var path = "/foo/5", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
+import_vitest.test.skip("chooses more exhaustive pattern", function () {
+  var path = "/foo/5",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bis",
+            params: {
+              id: 5
             },
-            {
-              name: "Bis",
-              params: {
-                id: 5
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("handles same paths beginnings", function() {
-  var path = "/foos", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos"
+(0, import_vitest.test)("handles same paths beginnings", function () {
+  var path = "/foos",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos"
+            }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
-            },
-            {
-              name: "Bis",
-              path
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bis",
+            path
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
-});
-import_vitest.test.skip("handles same paths beginnings with params", function() {
-  var path = "/foos/5", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
+});
+import_vitest.test.skip("handles same paths beginnings with params", function () {
+  var path = "/foos/5",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos/:id",
+              parse: {
+                id: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bis",
+            params: {
+              id: 5
             },
-            {
-              name: "Bis",
-              params: {
-                id: 5
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles not taking path with too many segments", function() {
-  var path = "/foos/5", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip",
-            parse: {
-              id: Number,
-              pwd: Number
+import_vitest.test.skip("handles not taking path with too many segments", function () {
+  var path = "/foos/5",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip",
+              parse: {
+                id: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bis",
+            params: {
+              id: 5
             },
-            {
-              name: "Bis",
-              params: {
-                id: 5
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles differently ordered params v1", function() {
-  var path = "/foos/5/res/20", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/res/:pwd",
-            parse: {
-              id: Number,
-              pwd: Number
+import_vitest.test.skip("handles differently ordered params v1", function () {
+  var path = "/foos/5/res/20",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/res/:pwd",
+              parse: {
+                id: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              pwd: 20
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                pwd: 20
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles differently ordered params v2", function() {
-  var path = "/5/20/foos/res", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: ":id/:pwd/foos/res",
-            parse: {
-              id: Number,
-              pwd: Number
+import_vitest.test.skip("handles differently ordered params v2", function () {
+  var path = "/5/20/foos/res",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: ":id/:pwd/foos/res",
+              parse: {
+                id: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              pwd: 20
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                pwd: 20
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles differently ordered params v3", function() {
-  var path = "/foos/5/20/res", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:pwd/res",
-            parse: {
-              id: Number,
-              pwd: Number
+import_vitest.test.skip("handles differently ordered params v3", function () {
+  var path = "/foos/5/20/res",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:pwd/res",
+              parse: {
+                id: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              pwd: 20
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                pwd: 20
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handles differently ordered params v4", function() {
-  var path = "5/foos/res/20", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: ":id/foos/res/:pwd",
-            parse: {
-              id: Number,
-              pwd: Number
+import_vitest.test.skip("handles differently ordered params v4", function () {
+  var path = "5/foos/res/20",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foos/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: ":id/foos/res/:pwd",
+              parse: {
+                id: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              pwd: 20
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                pwd: 20
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/5/foos/res/20"));
 });
-import_vitest.test.skip("handles simple optional params", function() {
-  var path = "/foos/5", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?",
-            parse: {
-              id: Number,
-              nip: Number
+import_vitest.test.skip("handles simple optional params", function () {
+  var path = "/foos/5",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?",
+              parse: {
+                id: Number,
+                nip: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle 2 optional params at the end v1", function() {
-  var path = "/foos/5", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?/:pwd?",
-            parse: {
-              id: Number,
-              nip: Number
+import_vitest.test.skip("handle 2 optional params at the end v1", function () {
+  var path = "/foos/5",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?/:pwd?",
+              parse: {
+                id: Number,
+                nip: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle 2 optional params at the end v2", function() {
-  var path = "/foos/5/10", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?/:pwd?",
-            parse: {
-              id: Number,
-              nip: Number
+import_vitest.test.skip("handle 2 optional params at the end v2", function () {
+  var path = "/foos/5/10",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?/:pwd?",
+              parse: {
+                id: Number,
+                nip: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              nip: 10
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                nip: 10
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle 2 optional params at the end v3", function() {
-  var path = "/foos/5/10/15", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?/:pwd?",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number
+import_vitest.test.skip("handle 2 optional params at the end v3", function () {
+  var path = "/foos/5/10/15",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?/:pwd?",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              nip: 10,
+              pwd: 15
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                nip: 10,
-                pwd: 15
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle optional params in the middle v1", function() {
-  var path = "/foos/5/10", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?/:pwd",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number
+import_vitest.test.skip("handle optional params in the middle v1", function () {
+  var path = "/foos/5/10",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?/:pwd",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              pwd: 10
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                pwd: 10
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle optional params in the middle v2", function() {
-  var path = "/foos/5/10/15", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?/:pwd",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number
+import_vitest.test.skip("handle optional params in the middle v2", function () {
+  var path = "/foos/5/10/15",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?/:pwd",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              nip: 10,
+              pwd: 15
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                nip: 10,
-                pwd: 15
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle optional params in the middle v3", function() {
-  var path = "/foos/5/10/15", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:id/:nip?/:pwd/:smh",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number,
-              smh: Number
+import_vitest.test.skip("handle optional params in the middle v3", function () {
+  var path = "/foos/5/10/15",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:id/:nip?/:pwd/:smh",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number,
+                smh: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              id: 5,
+              pwd: 10,
+              smh: 15
             },
-            {
-              name: "Bas",
-              params: {
-                id: 5,
-                pwd: 10,
-                smh: 15
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle optional params in the middle v4", function() {
-  var path = "/foos/5/10", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:nip?/:pwd/:smh?/:id",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number,
-              smh: Number
+import_vitest.test.skip("handle optional params in the middle v4", function () {
+  var path = "/foos/5/10",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:nip?/:pwd/:smh?/:id",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number,
+                smh: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              pwd: 5,
+              id: 10
             },
-            {
-              name: "Bas",
-              params: {
-                pwd: 5,
-                id: 10
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle optional params in the middle v5", function() {
-  var path = "/foos/5/10/15", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: "foos/:nip?/:pwd/:smh?/:id",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number,
-              smh: Number
+import_vitest.test.skip("handle optional params in the middle v5", function () {
+  var path = "/foos/5/10/15",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: "foos/:nip?/:pwd/:smh?/:id",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number,
+                smh: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              nip: 5,
+              pwd: 10,
+              id: 15
             },
-            {
-              name: "Bas",
-              params: {
-                nip: 5,
-                pwd: 10,
-                id: 15
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("handle optional params in the beginning v1", function() {
-  var path = "5/10/foos/15", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: ":nip?/:pwd/foos/:smh?/:id",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number,
-              smh: Number
+import_vitest.test.skip("handle optional params in the beginning v1", function () {
+  var path = "5/10/foos/15",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: ":nip?/:pwd/foos/:smh?/:id",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number,
+                smh: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              nip: 5,
+              pwd: 10,
+              id: 15
             },
-            {
-              name: "Bas",
-              params: {
-                nip: 5,
-                pwd: 10,
-                id: 15
-              },
-              path
-            }
-          ]
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/5/10/foos/15"));
 });
-import_vitest.test.skip("handle optional params in the beginning v2", function() {
-  var path = "5/10/foos/15", config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          },
-          Bas: {
-            path: ":nip?/:smh?/:pwd/foos/:id",
-            parse: {
-              id: Number,
-              nip: Number,
-              pwd: Number,
-              smh: Number
+import_vitest.test.skip("handle optional params in the beginning v2", function () {
+  var path = "5/10/foos/15",
+    config = {
+      screens: {
+        Foe: {
+          path: "/",
+          initialRouteName: "Foo",
+          screens: {
+            Foo: "foo",
+            Bis: {
+              path: "foo/:id",
+              parse: {
+                id: Number
+              }
+            },
+            Bas: {
+              path: ":nip?/:smh?/:pwd/foos/:id",
+              parse: {
+                id: Number,
+                nip: Number,
+                pwd: Number,
+                smh: Number
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foe",
         state: {
           index: 1,
-          routes: [
-            {
-              name: "Foo"
+          routes: [{
+            name: "Foo"
+          }, {
+            name: "Bas",
+            params: {
+              nip: 5,
+              pwd: 10,
+              id: 15
             },
-            {
-              name: "Bas",
-              params: {
-                nip: 5,
-                pwd: 10,
-                id: 15
-              },
-              path
-            }
-          ]
-        }
-      }
-    ]
-  };
-  (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/5/10/foos/15"));
-});
-import_vitest.test.skip("merges parent patterns if needed", function() {
-  var path = "foo/42/baz/babel", config = {
-    screens: {
-      Foo: {
-        path: "foo/:bar",
-        parse: {
-          bar: Number
-        },
-        screens: {
-          Baz: "baz/:qux"
+            path
+          }]
+        }
+      }]
+    };
+  (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/5/10/foos/15"));
+});
+import_vitest.test.skip("merges parent patterns if needed", function () {
+  var path = "foo/42/baz/babel",
+    config = {
+      screens: {
+        Foo: {
+          path: "foo/:bar",
+          parse: {
+            bar: Number
+          },
+          screens: {
+            Baz: "baz/:qux"
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         params: {
           bar: 42
         },
         state: {
-          routes: [
-            {
-              name: "Baz",
-              params: {
-                qux: "babel"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Baz",
+            params: {
+              qux: "babel"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/foo/42/baz/babel"));
 });
-import_vitest.test.skip("ignores extra slashes in the pattern", function() {
-  var path = "/bar/42", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar//:id/"
+import_vitest.test.skip("ignores extra slashes in the pattern", function () {
+  var path = "/bar/42",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar//:id/"
+            }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                id: "42"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Bar",
+            params: {
+              id: "42"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("matches wildcard patterns at root", function() {
-  var path = "/test/bar/42/whatever", config = {
-    screens: {
-      404: "*",
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/"
+import_vitest.test.skip("matches wildcard patterns at root", function () {
+  var path = "/test/bar/42/whatever",
+    config = {
+      screens: {
+        404: "*",
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/"
+            }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "404",
         path
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/404"));
 });
-import_vitest.test.skip("matches wildcard patterns at nested level", function() {
-  var path = "/bar/42/whatever/baz/initt", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              404: "*"
+import_vitest.test.skip("matches wildcard patterns at nested level", function () {
+  var path = "/bar/42/whatever/baz/initt",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                404: "*"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                id: "42"
-              },
-              state: {
-                routes: [
-                  {
-                    name: "404",
-                    path
-                  }
-                ]
-              }
+          routes: [{
+            name: "Bar",
+            params: {
+              id: "42"
+            },
+            state: {
+              routes: [{
+                name: "404",
+                path
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/bar/42/404"));
 });
-import_vitest.test.skip("matches wildcard patterns at nested level with exact", function() {
-  var path = "/whatever", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              404: {
-                path: "*",
-                exact: !0
+import_vitest.test.skip("matches wildcard patterns at nested level with exact", function () {
+  var path = "/whatever",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                404: {
+                  path: "*",
+                  exact: !0
+                }
               }
-            }
-          },
-          Baz: {}
+            },
+            Baz: {}
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              state: {
-                routes: [
-                  {
-                    name: "404",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "Bar",
+            state: {
+              routes: [{
+                name: "404",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/404"));
 });
-import_vitest.test.skip("tries to match wildcard patterns at the end", function() {
-  var path = "/bar/42/test", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              404: "*",
-              UserProfile: ":userSlug",
-              Test: "test"
+import_vitest.test.skip("tries to match wildcard patterns at the end", function () {
+  var path = "/bar/42/test",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                404: "*",
+                UserProfile: ":userSlug",
+                Test: "test"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                id: "42"
-              },
-              state: {
-                routes: [
-                  {
-                    name: "Test",
-                    path
-                  }
-                ]
-              }
+          routes: [{
+            name: "Bar",
+            params: {
+              id: "42"
+            },
+            state: {
+              routes: [{
+                name: "Test",
+                path
+              }]
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("uses nearest parent wildcard match for unmatched paths", function() {
-  var path = "/bar/42/baz/test", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              Baz: "baz"
-            }
-          },
-          404: "*"
+import_vitest.test.skip("uses nearest parent wildcard match for unmatched paths", function () {
+  var path = "/bar/42/baz/test",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                Baz: "baz"
+              }
+            },
+            404: "*"
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "404",
-              path
-            }
-          ]
+          routes: [{
+            name: "404",
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/404"));
 });
-import_vitest.test.skip("matches screen with overlapping initial path and wildcard", function() {
-  var path = "/bar/42/baz/test/whatever", config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              Baz: "baz"
-            }
-          },
-          Baz: "/bar/:id/*"
+import_vitest.test.skip("matches screen with overlapping initial path and wildcard", function () {
+  var path = "/bar/42/baz/test/whatever",
+    config = {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                Baz: "baz"
+              }
+            },
+            Baz: "/bar/:id/*"
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         state: {
-          routes: [
-            {
-              name: "Baz",
-              params: {
-                id: "42"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Baz",
+            params: {
+              id: "42"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(changePath(state, "/bar/42/Baz"));
 });
-(0, import_vitest.test)("throws if two screens map to the same pattern", function() {
+(0, import_vitest.test)("throws if two screens map to the same pattern", function () {
   var path = "/bar/42/baz/test";
-  (0, import_vitest.expect)(function() {
+  (0, import_vitest.expect)(function () {
     return (0, import_getStateFromPath.getStateFromPath)(path, {
       screens: {
         Foo: {
@@ -2321,7 +2158,7 @@ import_vitest.test.skip("matches screen with overlapping initial path and wildca
         }
       }
     });
-  }).toThrow("Found conflicting screens with the same pattern. The pattern 'bar/:id/baz' resolves to both 'Foo > Bax' and 'Foo > Bar > Baz'. Patterns must be unique and cannot resolve to more than one screen."), (0, import_vitest.expect)(function() {
+  }).toThrow("Found conflicting screens with the same pattern. The pattern 'bar/:id/baz' resolves to both 'Foo > Bax' and 'Foo > Bar > Baz'. Patterns must be unique and cannot resolve to more than one screen."), (0, import_vitest.expect)(function () {
     return (0, import_getStateFromPath.getStateFromPath)(path, {
       screens: {
         Foo: {
@@ -2338,106 +2175,97 @@ import_vitest.test.skip("matches screen with overlapping initial path and wildca
     });
   }).not.toThrow();
 });
-(0, import_vitest.test)("correctly applies initialRouteName for config with similar route names", function() {
-  var path = "/weekly-earnings", config = {
-    screens: {
-      RootTabs: {
-        screens: {
-          HomeTab: {
-            screens: {
-              Home: "",
-              WeeklyEarnings: "weekly-earnings",
-              EventDetails: "event-details/:eventId"
-            }
-          },
-          EarningsTab: {
-            initialRouteName: "Earnings",
-            path: "earnings",
-            screens: {
-              Earnings: "",
-              WeeklyEarnings: "weekly-earnings"
+(0, import_vitest.test)("correctly applies initialRouteName for config with similar route names", function () {
+  var path = "/weekly-earnings",
+    config = {
+      screens: {
+        RootTabs: {
+          screens: {
+            HomeTab: {
+              screens: {
+                Home: "",
+                WeeklyEarnings: "weekly-earnings",
+                EventDetails: "event-details/:eventId"
+              }
+            },
+            EarningsTab: {
+              initialRouteName: "Earnings",
+              path: "earnings",
+              screens: {
+                Earnings: "",
+                WeeklyEarnings: "weekly-earnings"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "RootTabs",
         state: {
-          routes: [
-            {
-              name: "HomeTab",
-              state: {
-                routes: [
-                  {
-                    name: "WeeklyEarnings",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "HomeTab",
+            state: {
+              routes: [{
+                name: "WeeklyEarnings",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-(0, import_vitest.test)("correctly applies initialRouteName for config with similar route names v2", function() {
-  var path = "/earnings/weekly-earnings", config = {
-    screens: {
-      RootTabs: {
-        screens: {
-          HomeTab: {
-            initialRouteName: "Home",
-            screens: {
-              Home: "",
-              WeeklyEarnings: "weekly-earnings"
-            }
-          },
-          EarningsTab: {
-            initialRouteName: "Earnings",
-            path: "earnings",
-            screens: {
-              Earnings: "",
-              WeeklyEarnings: "weekly-earnings"
+(0, import_vitest.test)("correctly applies initialRouteName for config with similar route names v2", function () {
+  var path = "/earnings/weekly-earnings",
+    config = {
+      screens: {
+        RootTabs: {
+          screens: {
+            HomeTab: {
+              initialRouteName: "Home",
+              screens: {
+                Home: "",
+                WeeklyEarnings: "weekly-earnings"
+              }
+            },
+            EarningsTab: {
+              initialRouteName: "Earnings",
+              path: "earnings",
+              screens: {
+                Earnings: "",
+                WeeklyEarnings: "weekly-earnings"
+              }
             }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "RootTabs",
         state: {
-          routes: [
-            {
-              name: "EarningsTab",
-              state: {
-                index: 1,
-                routes: [
-                  {
-                    name: "Earnings"
-                  },
-                  {
-                    name: "WeeklyEarnings",
-                    path
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  };
+          routes: [{
+            name: "EarningsTab",
+            state: {
+              index: 1,
+              routes: [{
+                name: "Earnings"
+              }, {
+                name: "WeeklyEarnings",
+                path
+              }]
+            }
+          }]
+        }
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)((0, import_getPathFromState.getPathFromState)(state, config), config)).toEqual(state);
 });
-import_vitest.test.skip("throws when invalid properties are specified in the config", function() {
-  (0, import_vitest.expect)(function() {
+import_vitest.test.skip("throws when invalid properties are specified in the config", function () {
+  (0, import_vitest.expect)(function () {
     return (0, import_getStateFromPath.getStateFromPath)("", {
       path: 42,
       Foo: "foo",
@@ -2459,7 +2287,7 @@ import_vitest.test.skip("throws when invalid properties are specified in the con
     If you want to specify configuration for screens, you need to specify them under a 'screens' property.
 
     See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration."
-  `), (0, import_vitest.expect)(function() {
+  `), (0, import_vitest.expect)(function () {
     return (0, import_getStateFromPath.getStateFromPath)("", {
       screens: {
         Foo: "foo",
@@ -2489,79 +2317,78 @@ You can only specify the following properties:
 If you want to specify configuration for screens, you need to specify them under a 'screens' property.
 
 See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration."
-`), (0, import_vitest.expect)(function() {
+`), (0, import_vitest.expect)(function () {
     return (0, import_getStateFromPath.getStateFromPath)("", {
       path: "foo/:id"
     });
   }).toThrowErrorMatchingInlineSnapshot(`"Found invalid path 'foo/:id'. The 'path' in the top-level configuration cannot contain patterns for params."`);
 });
-import_vitest.test.skip("encodes special characters in params", function() {
-  var paramWithValidSymbols = "User09-A_Z~!$&'()*+,;=:@__", invalidSymbols = "#?[]{}%<>||", queryString = "user#email@gmail.com=2&4", path = `users/id/${paramWithValidSymbols}${encodeURIComponent(invalidSymbols)}?query=${encodeURIComponent(queryString)}`, config = {
-    path: "users",
-    screens: {
-      Users: {
-        screens: {
-          User: "id/:id"
+import_vitest.test.skip("encodes special characters in params", function () {
+  var paramWithValidSymbols = "User09-A_Z~!$&'()*+,;=:@__",
+    invalidSymbols = "#?[]{}%<>||",
+    queryString = "user#email@gmail.com=2&4",
+    path = `users/id/${paramWithValidSymbols}${encodeURIComponent(invalidSymbols)}?query=${encodeURIComponent(queryString)}`,
+    config = {
+      path: "users",
+      screens: {
+        Users: {
+          screens: {
+            User: "id/:id"
+          }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Users",
         state: {
-          routes: [
-            {
-              name: "User",
-              params: {
-                id: `${paramWithValidSymbols}${invalidSymbols}`,
-                query: queryString
-              }
+          routes: [{
+            name: "User",
+            params: {
+              id: `${paramWithValidSymbols}${invalidSymbols}`,
+              query: queryString
             }
-          ]
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)(state, config)).toBe(`/${path}`), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)(path, config), config)).toBe(`/${path}`);
 });
-import_vitest.test.skip("resolves nested path params with same name to correct screen", function() {
-  var path = "/foo/42/bar/43", config = {
-    initialRouteName: "Foo",
-    screens: {
-      Foo: {
-        path: "foo/:id",
-        screens: {
-          Bar: {
-            path: "bar/:id"
+import_vitest.test.skip("resolves nested path params with same name to correct screen", function () {
+  var path = "/foo/42/bar/43",
+    config = {
+      initialRouteName: "Foo",
+      screens: {
+        Foo: {
+          path: "foo/:id",
+          screens: {
+            Bar: {
+              path: "bar/:id"
+            }
           }
         }
       }
-    }
-  }, state = {
-    routes: [
-      {
+    },
+    state = {
+      routes: [{
         name: "Foo",
         params: {
           id: "42"
         },
         state: {
-          routes: [
-            {
-              name: "Bar",
-              params: {
-                id: "43"
-              },
-              path
-            }
-          ]
+          routes: [{
+            name: "Bar",
+            params: {
+              id: "43"
+            },
+            path
+          }]
         }
-      }
-    ]
-  };
+      }]
+    };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)(path, config)).toEqual(state);
 });
-(0, import_vitest.test)("parses / same as empty string", function() {
+(0, import_vitest.test)("parses / same as empty string", function () {
   var config = {
     screens: {
       Foo: {
@@ -2574,7 +2401,7 @@ import_vitest.test.skip("resolves nested path params with same name to correct s
   };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("/", config)).toEqual((0, import_getStateFromPath.getStateFromPath)("", config));
 });
-import_vitest.test.skip("matches regexp patterns when provided", function() {
+import_vitest.test.skip("matches regexp patterns when provided", function () {
   var config = {
     screens: {
       Foo: {
@@ -2592,7 +2419,7 @@ import_vitest.test.skip("matches regexp patterns when provided", function() {
       Qux: {
         path: "foo/:id(@[a-z]+)",
         parse: {
-          id: function(id) {
+          id: function (id) {
             return id.slice(1);
           }
         }
@@ -2612,93 +2439,75 @@ import_vitest.test.skip("matches regexp patterns when provided", function() {
     }
   };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/42", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        params: {
-          id: 42
-        },
-        path: "foo/42"
-      }
-    ]
+    routes: [{
+      name: "Foo",
+      params: {
+        id: 42
+      },
+      path: "foo/42"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar", config)).toEqual({
-    routes: [
-      {
-        name: "Bar",
-        params: {
-          id: "bar"
-        },
-        path: "foo/bar"
-      }
-    ]
+    routes: [{
+      name: "Bar",
+      params: {
+        id: "bar"
+      },
+      path: "foo/bar"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/42/bar", config)).toEqual({
-    routes: [
-      {
-        name: "Baz",
-        params: {
-          id: "42",
-          name: "bar"
-        },
-        path: "foo/42/bar"
-      }
-    ]
+    routes: [{
+      name: "Baz",
+      params: {
+        id: "42",
+        name: "bar"
+      },
+      path: "foo/42/bar"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/@bar", config)).toEqual({
-    routes: [
-      {
-        name: "Qux",
-        params: {
-          id: "bar"
-        },
-        path: "foo/@bar"
-      }
-    ]
+    routes: [{
+      name: "Qux",
+      params: {
+        id: "bar"
+      },
+      path: "foo/@bar"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/@bar", config)).toEqual({
-    routes: [
-      {
-        name: "Qux",
-        params: {
-          id: "bar"
-        },
-        path: "foo/@bar"
-      }
-    ]
+    routes: [{
+      name: "Qux",
+      params: {
+        id: "bar"
+      },
+      path: "foo/@bar"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/42a", config)).toBeUndefined(), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/123", config)).toEqual({
-    routes: [
-      {
-        name: "Quy",
-        params: {
-          category: "123"
-        },
-        path: "foo/bar/123"
-      }
-    ]
+    routes: [{
+      name: "Quy",
+      params: {
+        category: "123"
+      },
+      path: "foo/bar/123"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/test", config)).toEqual({
-    routes: [
-      {
-        name: "Quz",
-        params: {
-          special: "test"
-        },
-        path: "foo/bar/test"
-      }
-    ]
+    routes: [{
+      name: "Quz",
+      params: {
+        special: "test"
+      },
+      path: "foo/bar/test"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/baz", config)).toEqual({
-    routes: [
-      {
-        name: "Quu",
-        path: "foo/bar/baz"
-      }
-    ]
+    routes: [{
+      name: "Quu",
+      path: "foo/bar/baz"
+    }]
   }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/hello/world", config)).toEqual({
-    routes: [
-      {
-        name: "NotFound",
-        path: "foo/bar/hello/world"
-      }
-    ]
+    routes: [{
+      name: "NotFound",
+      path: "foo/bar/hello/world"
+    }]
   });
 });
-(0, import_vitest.test)("regexp pattern doesn't match slash", function() {
+(0, import_vitest.test)("regexp pattern doesn't match slash", function () {
   var config = {
     screens: {
       Foo: {
@@ -2708,37 +2517,31 @@ import_vitest.test.skip("matches regexp patterns when provided", function() {
   };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/", config)).toBeUndefined(), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/baz", config)).toBeUndefined(), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/baz/qux", config)).toBeUndefined();
 });
-import_vitest.test.skip("handles alias for paths", function() {
+import_vitest.test.skip("handles alias for paths", function () {
   var config = {
     screens: {
       Foo: {
         path: "foo",
-        alias: [
-          "first"
-        ],
+        alias: ["first"],
         screens: {
           Baz: {
             path: "baz/:id?",
             parse: {
-              id: function(value) {
+              id: function (value) {
                 return value.replace(/@/, "");
               }
             },
-            alias: [
-              {
-                path: "second/:id",
-                exact: !0
-              },
-              "third",
-              {
-                path: "fourth/:id",
-                parse: {
-                  id: function(value) {
-                    return value.replace(/\$/, "");
-                  }
+            alias: [{
+              path: "second/:id",
+              exact: !0
+            }, "third", {
+              path: "fourth/:id",
+              parse: {
+                id: function (value) {
+                  return value.replace(/\$/, "");
                 }
               }
-            ]
+            }]
           },
           Qux: {
             path: "qux/:id"
@@ -2748,114 +2551,88 @@ import_vitest.test.skip("handles alias for paths", function() {
     }
   };
   (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        path: "foo"
-      }
-    ]
+    routes: [{
+      name: "Foo",
+      path: "foo"
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("foo", config), config)).toBe("/foo"), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("first", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        path: "first"
-      }
-    ]
+    routes: [{
+      name: "Foo",
+      path: "first"
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("first", config), config)).toBe("/foo"), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/baz/@$test", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        state: {
-          routes: [
-            {
-              name: "Baz",
-              params: {
-                id: "$test"
-              },
-              path: "foo/baz/@$test"
-            }
-          ]
-        }
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Baz",
+          params: {
+            id: "$test"
+          },
+          path: "foo/baz/@$test"
+        }]
       }
-    ]
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("foo/baz/@$test", config), config)).toBe("/foo/baz/$test"), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("second/42", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        state: {
-          routes: [
-            {
-              name: "Baz",
-              params: {
-                id: "42"
-              },
-              path: "second/42"
-            }
-          ]
-        }
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Baz",
+          params: {
+            id: "42"
+          },
+          path: "second/42"
+        }]
       }
-    ]
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("second/42", config), config)).toBe("/foo/baz/42"), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/third", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        state: {
-          routes: [
-            {
-              name: "Baz",
-              path: "foo/third"
-            }
-          ]
-        }
-      }
-    ]
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Baz",
+          path: "foo/third"
+        }]
+      }
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("foo/third", config), config)).toBe("/foo/baz"), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/fourth/@$test", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        state: {
-          routes: [
-            {
-              name: "Baz",
-              params: {
-                id: "@test"
-              },
-              path: "foo/fourth/@$test"
-            }
-          ]
-        }
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Baz",
+          params: {
+            id: "@test"
+          },
+          path: "foo/fourth/@$test"
+        }]
       }
-    ]
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("foo/fourth/@$test", config), config)).toBe("/foo/baz/@test"), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/qux/42", config)).toEqual({
-    routes: [
-      {
-        name: "Foo",
-        state: {
-          routes: [
-            {
-              name: "Qux",
-              params: {
-                id: "42"
-              },
-              path: "foo/qux/42"
-            }
-          ]
-        }
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Qux",
+          params: {
+            id: "42"
+          },
+          path: "foo/qux/42"
+        }]
       }
-    ]
+    }]
   }), (0, import_vitest.expect)((0, import_getPathFromState.getPathFromState)((0, import_getStateFromPath.getStateFromPath)("foo/qux/42", config), config)).toBe("/foo/qux/42");
 });
-import_vitest.test.skip("throws if screen has alias but no path", function() {
-  (0, import_vitest.expect)(function() {
+import_vitest.test.skip("throws if screen has alias but no path", function () {
+  (0, import_vitest.expect)(function () {
     return (0, import_getStateFromPath.getStateFromPath)("", {
       screens: {
         Foo: {
-          alias: [
-            "bar"
-          ]
+          alias: ["bar"]
         }
       }
     });
   }).toThrow("Screen 'Foo' doesn't specify a 'path'. A 'path' needs to be specified in order to use 'alias'.");
 });
-//# sourceMappingURL=getStateFromPath.test.js.map
+//# sourceMappingURL=getStateFromPath.test.native.js.map