one 1.1.473 → 1.1.475

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

@@ -0,0 +1,2861 @@
+"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() {
+  (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: [
+      {
+        name: "foo",
+        state: {
+          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"
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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"
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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();
+                    });
+                  },
+                  count: Number,
+                  valid: Boolean
+                },
+                stringify: {
+                  author: function(author) {
+                    return author.toLowerCase();
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, 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
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  };
+  (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() {
+  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
+            }
+          ]
+        }
+      }
+    ]
+  });
+});
+(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
+            }
+          ]
+        }
+      }
+    ]
+  });
+});
+(0, import_vitest.test)("handles route without param", function() {
+  var path = "foo/bar", state = {
+    routes: [
+      {
+        name: "foo",
+        state: {
+          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();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
+                    },
+                    stringify: {
+                      author: function(author) {
+                        return author.toLowerCase();
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          routes: [
+            {
+              name: "Foe",
+              state: {
+                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);
+});
+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: [
+      {
+        name: "Foo",
+        state: {
+          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();
+                            });
+                          }
+                        },
+                        parse: {
+                          author: function(author) {
+                            return author.replace(/^\w/, function(c) {
+                              return c.toUpperCase();
+                            });
+                          },
+                          count: Number,
+                          valid: Boolean
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Bar",
+        params: {
+          fruit: "apple",
+          type: "sweet"
+        },
+        state: {
+          routes: [
+            {
+              name: "Foo",
+              state: {
+                routes: [
+                  {
+                    name: "Foe",
+                    state: {
+                      routes: [
+                        {
+                          name: "Baz",
+                          state: {
+                            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
+              }
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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
+              }
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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"
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    index: 1,
+    routes: [
+      {
+        name: "Boo"
+      },
+      {
+        name: "Foo",
+        state: {
+          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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          index: 1,
+          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"
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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();
+                            });
+                          }
+                        },
+                        parse: {
+                          author: function(author) {
+                            return author.replace(/^\w/, function(c) {
+                              return c.toUpperCase();
+                            });
+                          },
+                          count: Number,
+                          valid: Boolean
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Bar",
+        params: {
+          fruit: "apple",
+          type: "sweet"
+        },
+        state: {
+          routes: [
+            {
+              name: "Foo",
+              state: {
+                routes: [
+                  {
+                    name: "Foe",
+                    state: {
+                      routes: [
+                        {
+                          name: "Baz",
+                          state: {
+                            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();
+                            });
+                          }
+                        },
+                        parse: {
+                          author: function(author) {
+                            return author.replace(/^\w/, function(c) {
+                              return c.toUpperCase();
+                            });
+                          },
+                          count: Number,
+                          valid: Boolean
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Bar",
+        params: {
+          fruit: "apple",
+          type: "sweet"
+        },
+        state: {
+          routes: [
+            {
+              name: "Foo",
+              state: {
+                routes: [
+                  {
+                    name: "Foe",
+                    state: {
+                      routes: [
+                        {
+                          name: "Baz",
+                          state: {
+                            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.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.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.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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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() {
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            path: "bar",
+            screens: {
+              Qux: {
+                path: "",
+                parse: {
+                  foo: Number
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, 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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bis",
+              params: {
+                id: 5
+              },
+              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"
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bis",
+              params: {
+                id: 5
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bis",
+              params: {
+                id: 5
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                pwd: 20
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                pwd: 20
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                pwd: 20
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                pwd: 20
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                nip: 10
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                nip: 10,
+                pwd: 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(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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                pwd: 10
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                nip: 10,
+                pwd: 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(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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                id: 5,
+                pwd: 10,
+                smh: 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(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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              name: "Bas",
+              params: {
+                pwd: 5,
+                id: 10
+              },
+              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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              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(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
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              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("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: [
+      {
+        name: "Foe",
+        state: {
+          index: 1,
+          routes: [
+            {
+              name: "Foo"
+            },
+            {
+              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"
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        params: {
+          bar: 42
+        },
+        state: {
+          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/"
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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/"
+          }
+        }
+      }
+    }
+  }, 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: "*"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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
+              }
+            }
+          },
+          Baz: {}
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        state: {
+          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: "*"
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        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 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: [
+      {
+        name: "Foo",
+        state: {
+          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() {
+  var path = "/bar/42/baz/test";
+  (0, import_vitest.expect)(function() {
+    return (0, import_getStateFromPath.getStateFromPath)(path, {
+      screens: {
+        Foo: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                Baz: "baz"
+              }
+            },
+            Bax: "/bar/:id/baz"
+          }
+        }
+      }
+    });
+  }).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: {
+          screens: {
+            Bar: {
+              path: "/bar/:id/",
+              screens: {
+                Baz: ""
+              }
+            }
+          }
+        }
+      }
+    });
+  }).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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "RootTabs",
+        state: {
+          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"
+            }
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "RootTabs",
+        state: {
+          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() {
+    return (0, import_getStateFromPath.getStateFromPath)("", {
+      path: 42,
+      Foo: "foo",
+      Bar: {
+        path: "bar"
+      }
+    });
+  }).toThrowErrorMatchingInlineSnapshot(`
+    "Found invalid properties in the configuration:
+    - path (expected 'string', got 'number')
+    - Foo (extraneous)
+    - Bar (extraneous)
+
+    You can only specify the following properties:
+    - path (string)
+    - initialRouteName (string)
+    - screens (object)
+
+    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() {
+    return (0, import_getStateFromPath.getStateFromPath)("", {
+      screens: {
+        Foo: "foo",
+        Bar: {
+          path: "bar"
+        },
+        Baz: {
+          Qux: {
+            path: "qux"
+          }
+        }
+      }
+    });
+  }).toThrowErrorMatchingInlineSnapshot(`
+"Found invalid properties in the configuration:
+- Qux (extraneous)
+
+You can only specify the following properties:
+- path (string)
+- initialRouteName (string)
+- screens (object)
+- alias (array)
+- exact (boolean)
+- stringify (object)
+- parse (object)
+
+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() {
+    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"
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Users",
+        state: {
+          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"
+          }
+        }
+      }
+    }
+  }, state = {
+    routes: [
+      {
+        name: "Foo",
+        params: {
+          id: "42"
+        },
+        state: {
+          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() {
+  var config = {
+    screens: {
+      Foo: {
+        path: "/"
+      },
+      Bar: {
+        path: "bar"
+      }
+    }
+  };
+  (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() {
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo/:id(\\d+)",
+        parse: {
+          id: Number
+        }
+      },
+      Bar: {
+        path: "foo/:id([a-z]+)"
+      },
+      Baz: {
+        path: "foo/:id(\\d+)/:name([a-z]+)"
+      },
+      Qux: {
+        path: "foo/:id(@[a-z]+)",
+        parse: {
+          id: function(id) {
+            return id.slice(1);
+          }
+        }
+      },
+      Quy: {
+        path: "foo/bar/:category"
+      },
+      Quz: {
+        path: "foo/bar/:special([a-z]+)"
+      },
+      Quu: {
+        path: "foo/bar/baz"
+      },
+      NotFound: {
+        path: "foo/bar/*"
+      }
+    }
+  };
+  (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/42", config)).toEqual({
+    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"
+      }
+    ]
+  }), (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"
+      }
+    ]
+  }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/@bar", config)).toEqual({
+    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"
+      }
+    ]
+  }), (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"
+      }
+    ]
+  }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/test", config)).toEqual({
+    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"
+      }
+    ]
+  }), (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo/bar/hello/world", config)).toEqual({
+    routes: [
+      {
+        name: "NotFound",
+        path: "foo/bar/hello/world"
+      }
+    ]
+  });
+});
+(0, import_vitest.test)("regexp pattern doesn't match slash", function() {
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo/:id([a-z]+\\/)"
+      }
+    }
+  };
+  (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() {
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        alias: [
+          "first"
+        ],
+        screens: {
+          Baz: {
+            path: "baz/: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"
+          }
+        }
+      }
+    }
+  };
+  (0, import_vitest.expect)((0, import_getStateFromPath.getStateFromPath)("foo", config)).toEqual({
+    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"
+      }
+    ]
+  }), (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"
+            }
+          ]
+        }
+      }
+    ]
+  }), (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"
+            }
+          ]
+        }
+      }
+    ]
+  }), (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"
+            }
+          ]
+        }
+      }
+    ]
+  }), (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"
+            }
+          ]
+        }
+      }
+    ]
+  }), (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"
+            }
+          ]
+        }
+      }
+    ]
+  }), (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() {
+    return (0, import_getStateFromPath.getStateFromPath)("", {
+      screens: {
+        Foo: {
+          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