one 1.25.4 → 1.25.5

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

@@ -1,2748 +0,0 @@
-import { produce } from "immer";
-import { expect, test } from "vitest";
-import { findFocusedRoute } from "../findFocusedRoute.native.js";
-import { getPathFromState } from "../getPathFromState.native.js";
-import { getStateFromPath } from "../getStateFromPath.native.js";
-var changePath = function (state, path) {
-  return produce(state, function (draftState) {
-    var route = findFocusedRoute(draftState);
-    route.path = path;
-  });
-};
-test("returns undefined for invalid path", function () {
-  expect(getStateFromPath("//")).toBeUndefined();
-});
-test.skip("converts path string to initial state", function () {
-  var path = "foo/bar/baz%20qux?author=jane%20%26%20co&valid=true";
-  var state = {
-    routes: [{
-      name: "foo",
-      state: {
-        routes: [{
-          name: "bar",
-          state: {
-            routes: [{
-              name: "baz qux",
-              params: {
-                author: "jane & co",
-                valid: "true"
-              },
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state))).toEqual(changePath(state, "/foo/bar/baz%20qux?author=jane%20%26%20co&valid=true"));
-});
-test.skip("decodes encoded params in path", function () {
-  var path = "/foo/bar/bar_%23_foo";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Bar: {
-            path: "/bar/:id"
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          params: {
-            id: "bar_#_foo"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getPathFromState(getStateFromPath(path, config), config)).toEqual(path);
-});
-test.skip("decodes encoded params in path that have encoded /", function () {
-  var path = "/foo/bar/bar_%2F_foo";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Bar: {
-            path: "/bar/:id"
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          params: {
-            id: "bar_/_foo"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getPathFromState(getStateFromPath(path, config), config)).toEqual(path);
-});
-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";
-  var 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();
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var 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: true
-              },
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles leading slash when converting", function () {
-  var path = "/foo/bar/?count=42";
-  expect(getStateFromPath(path)).toEqual({
-    routes: [{
-      name: "foo",
-      key: "foo-0",
-      state: {
-        routes: [{
-          name: "bar",
-          key: "bar-1",
-          params: {
-            count: "42"
-          },
-          path
-        }]
-      }
-    }]
-  });
-});
-test("handles ending slash when converting", function () {
-  var path = "foo/bar/?count=42";
-  expect(getStateFromPath(path)).toEqual({
-    routes: [{
-      name: "foo",
-      key: "foo-0",
-      state: {
-        routes: [{
-          name: "bar",
-          key: "bar-1",
-          params: {
-            count: "42"
-          },
-          path
-        }]
-      }
-    }]
-  });
-});
-test("handles route without param", function () {
-  var path = "foo/bar";
-  var state = {
-    routes: [{
-      name: "foo",
-      key: "foo-0",
-      state: {
-        routes: [{
-          name: "bar",
-          key: "bar-1",
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state))).toEqual(changePath(state, "/foo/bar"));
-});
-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";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: {
-            path: "foe",
-            exact: true,
-            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();
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var 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: true
-                  },
-                  path
-                }]
-              }
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-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";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: {
-            path: "foe",
-            exact: true,
-            screens: {
-              Baz: {
-                path: "baz/:author",
-                parse: {
-                  author: function (author) {
-                    return author.replace(/^\w/, function (c) {
-                      return c.toUpperCase();
-                    });
-                  },
-                  count: Number,
-                  valid: Boolean,
-                  id: Boolean
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Foe",
-          state: {
-            routes: [{
-              name: "Baz",
-              params: {
-                author: "Jane",
-                count: 10,
-                answer: "42",
-                valid: true
-              },
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/foe/baz/Jane?count=10&answer=42&valid=true"));
-});
-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";
-  var config = {
-    screens: {
-      Bar: {
-        path: "bar/:type/:fruit",
-        screens: {
-          Foo: {
-            screens: {
-              Foe: {
-                path: "foe",
-                screens: {
-                  Baz: {
-                    screens: {
-                      Bos: {
-                        path: "bos",
-                        exact: true
-                      },
-                      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
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var 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: true
-                      },
-                      path
-                    }]
-                  }
-                }]
-              }
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles parse in nested object for second route depth", function () {
-  var path = "/baz";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: {
-            path: "foe",
-            exact: true
-          },
-          Bar: {
-            path: "bar",
-            exact: true,
-            screens: {
-              Baz: {
-                path: "baz",
-                exact: true
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      key: "Foo-0",
-      state: {
-        routes: [{
-          name: "Bar",
-          key: "Bar-1",
-          state: {
-            routes: [{
-              name: "Baz",
-              key: "Baz-2",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles parse in nested object for second route depth and and path and parse in roots", function () {
-  var path = "/baz";
-  var 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: true
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      key: "Foo-0",
-      state: {
-        routes: [{
-          name: "Bar",
-          key: "Bar-1",
-          state: {
-            routes: [{
-              name: "Baz",
-              key: "Baz-2",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles path at top level", function () {
-  var path = "/foo/fruits/apple";
-  var config = {
-    path: "foo",
-    screens: {
-      Foo: {
-        screens: {
-          Fruits: "fruits/:fruit"
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Fruits",
-          params: {
-            fruit: "apple"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles initialRouteName at top level", function () {
-  var path = "/baz";
-  var config = {
-    initialRouteName: "Boo",
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    index: 1,
-    routes: [{
-      name: "Boo",
-      key: "Boo-0"
-    }, {
-      name: "Foo",
-      key: "Foo-1",
-      state: {
-        routes: [{
-          name: "Bar",
-          key: "Bar-2",
-          state: {
-            routes: [{
-              name: "Baz",
-              key: "Baz-3",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles initialRouteName inside a screen", function () {
-  var path = "/baz";
-  var config = {
-    screens: {
-      Foo: {
-        initialRouteName: "Foe",
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      key: "Foo-0",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foe",
-          key: "Foe-1"
-        }, {
-          name: "Bar",
-          key: "Bar-2",
-          state: {
-            routes: [{
-              name: "Baz",
-              key: "Baz-3",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles initialRouteName included in path", function () {
-  var path = "/baz";
-  var config = {
-    screens: {
-      Foo: {
-        initialRouteName: "Foe",
-        screens: {
-          Foe: {
-            screens: {
-              Baz: "baz"
-            }
-          },
-          Bar: "bar"
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      key: "Foo-0",
-      state: {
-        routes: [{
-          name: "Foe",
-          key: "Foe-1",
-          state: {
-            routes: [{
-              name: "Baz",
-              key: "Baz-2",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles two initialRouteNames", function () {
-  var path = "/bar/sweet/apple/foe/bis/jane?answer=42&count=10&valid=true";
-  var config = {
-    screens: {
-      Bar: {
-        path: "bar/:type/:fruit",
-        screens: {
-          Foo: {
-            screens: {
-              Foe: {
-                path: "foe",
-                screens: {
-                  Baz: {
-                    initialRouteName: "Bos",
-                    screens: {
-                      Bos: {
-                        path: "bos",
-                        exact: true
-                      },
-                      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
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var 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: true
-                      },
-                      path
-                    }]
-                  }
-                }]
-              }
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("accepts initialRouteName without config for it", function () {
-  var path = "/bar/sweet/apple/foe/bis/jane?answer=42&count=10&valid=true";
-  var config = {
-    screens: {
-      Bar: {
-        path: "bar/:type/:fruit",
-        screens: {
-          Foo: {
-            screens: {
-              Foe: {
-                path: "foe",
-                screens: {
-                  Baz: {
-                    initialRouteName: "Bas",
-                    screens: {
-                      Bos: {
-                        path: "bos",
-                        exact: true
-                      },
-                      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
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var 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: true
-                      },
-                      path
-                    }]
-                  }
-                }]
-              }
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("returns undefined if no matching screen is present (top level path)", function () {
-  var path = "/foo/bar";
-  var config = {
-    path: "qux",
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foo",
-          Bar: {
-            screens: {
-              Baz: "bar"
-            }
-          }
-        }
-      }
-    }
-  };
-  expect(getStateFromPath(path, config)).toBeUndefined();
-});
-test("returns undefined if no matching screen is present", function () {
-  var path = "/baz";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo",
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  expect(getStateFromPath(path, config)).toBeUndefined();
-});
-test("returns undefined if path is empty and no matching screen is present", function () {
-  var path = "";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  expect(getStateFromPath(path, config)).toBeUndefined();
-});
-test.skip("returns matching screen if path is empty", function () {
-  var path = "";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Qux: "",
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          state: {
-            routes: [{
-              name: "Qux",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, ""));
-});
-test.skip("returns matching screen if path is only slash", function () {
-  var path = "/";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Qux: "",
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          state: {
-            routes: [{
-              name: "Qux",
-              path: ""
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, ""));
-});
-test("returns matching screen with params if path is empty", function () {
-  var path = "?foo=42";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Foe: "foe",
-          Bar: {
-            screens: {
-              Qux: {
-                path: "",
-                parse: {
-                  foo: Number
-                }
-              },
-              Baz: "baz"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      key: "Foo-0",
-      state: {
-        routes: [{
-          name: "Bar",
-          key: "Bar-1",
-          state: {
-            routes: [{
-              name: "Qux",
-              key: "Qux-2",
-              params: {
-                foo: 42
-              },
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/?foo=42"));
-});
-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
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var path = "";
-  expect(getStateFromPath(path, config)).toBeUndefined();
-});
-test.skip("chooses more exhaustive pattern", function () {
-  var path = "/foo/5";
-  var config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foo/:id",
-            parse: {
-              id: Number
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bis",
-          params: {
-            id: 5
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("handles same paths beginnings", function () {
-  var path = "/foos";
-  var config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos"
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      key: "Foe-0",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo",
-          key: "Foo-1"
-        }, {
-          name: "Bis",
-          key: "Bis-2",
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles same paths beginnings with params", function () {
-  var path = "/foos/5";
-  var config = {
-    screens: {
-      Foe: {
-        path: "/",
-        initialRouteName: "Foo",
-        screens: {
-          Foo: "foo",
-          Bis: {
-            path: "foos/:id",
-            parse: {
-              id: Number
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bis",
-          params: {
-            id: 5
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles not taking path with too many segments", function () {
-  var path = "/foos/5";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bis",
-          params: {
-            id: 5
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles differently ordered params v1", function () {
-  var path = "/foos/5/res/20";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            pwd: 20
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles differently ordered params v2", function () {
-  var path = "/5/20/foos/res";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            pwd: 20
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles differently ordered params v3", function () {
-  var path = "/foos/5/20/res";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            pwd: 20
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handles differently ordered params v4", function () {
-  var path = "5/foos/res/20";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            pwd: 20
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/5/foos/res/20"));
-});
-test.skip("handles simple optional params", function () {
-  var path = "/foos/5";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle 2 optional params at the end v1", function () {
-  var path = "/foos/5";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle 2 optional params at the end v2", function () {
-  var path = "/foos/5/10";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            nip: 10
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle 2 optional params at the end v3", function () {
-  var path = "/foos/5/10/15";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            nip: 10,
-            pwd: 15
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle optional params in the middle v1", function () {
-  var path = "/foos/5/10";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            pwd: 10
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle optional params in the middle v2", function () {
-  var path = "/foos/5/10/15";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            nip: 10,
-            pwd: 15
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle optional params in the middle v3", function () {
-  var path = "/foos/5/10/15";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            id: 5,
-            pwd: 10,
-            smh: 15
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle optional params in the middle v4", function () {
-  var path = "/foos/5/10";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            pwd: 5,
-            id: 10
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle optional params in the middle v5", function () {
-  var path = "/foos/5/10/15";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            nip: 5,
-            pwd: 10,
-            id: 15
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("handle optional params in the beginning v1", function () {
-  var path = "5/10/foos/15";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            nip: 5,
-            pwd: 10,
-            id: 15
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/5/10/foos/15"));
-});
-test.skip("handle optional params in the beginning v2", function () {
-  var path = "5/10/foos/15";
-  var 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
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foe",
-      state: {
-        index: 1,
-        routes: [{
-          name: "Foo"
-        }, {
-          name: "Bas",
-          params: {
-            nip: 5,
-            pwd: 10,
-            id: 15
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/5/10/foos/15"));
-});
-test.skip("merges parent patterns if needed", function () {
-  var path = "foo/42/baz/babel";
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo/:bar",
-        parse: {
-          bar: Number
-        },
-        screens: {
-          Baz: "baz/:qux"
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      params: {
-        bar: 42
-      },
-      state: {
-        routes: [{
-          name: "Baz",
-          params: {
-            qux: "babel"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/foo/42/baz/babel"));
-});
-test.skip("ignores extra slashes in the pattern", function () {
-  var path = "/bar/42";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar//:id/"
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          params: {
-            id: "42"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("matches wildcard patterns at root", function () {
-  var path = "/test/bar/42/whatever";
-  var config = {
-    screens: {
-      404: "*",
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/"
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "404",
-      path
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/404"));
-});
-test.skip("matches wildcard patterns at nested level", function () {
-  var path = "/bar/42/whatever/baz/initt";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              404: "*"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          params: {
-            id: "42"
-          },
-          state: {
-            routes: [{
-              name: "404",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/bar/42/404"));
-});
-test.skip("matches wildcard patterns at nested level with exact", function () {
-  var path = "/whatever";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              404: {
-                path: "*",
-                exact: true
-              }
-            }
-          },
-          Baz: {}
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          state: {
-            routes: [{
-              name: "404",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/404"));
-});
-test.skip("tries to match wildcard patterns at the end", function () {
-  var path = "/bar/42/test";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              404: "*",
-              UserProfile: ":userSlug",
-              Test: "test"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Bar",
-          params: {
-            id: "42"
-          },
-          state: {
-            routes: [{
-              name: "Test",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("uses nearest parent wildcard match for unmatched paths", function () {
-  var path = "/bar/42/baz/test";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              Baz: "baz"
-            }
-          },
-          404: "*"
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "404",
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/404"));
-});
-test.skip("matches screen with overlapping initial path and wildcard", function () {
-  var path = "/bar/42/baz/test/whatever";
-  var config = {
-    screens: {
-      Foo: {
-        screens: {
-          Bar: {
-            path: "/bar/:id/",
-            screens: {
-              Baz: "baz"
-            }
-          },
-          Baz: "/bar/:id/*"
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Baz",
-          params: {
-            id: "42"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/bar/42/Baz"));
-});
-test("throws if two screens map to the same pattern", function () {
-  var path = "/bar/42/baz/test";
-  expect(function () {
-    return 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.");
-  expect(function () {
-    return getStateFromPath(path, {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                Baz: ""
-              }
-            }
-          }
-        }
-      }
-    });
-  }).not.toThrow();
-});
-test("correctly applies initialRouteName for config with similar route names", function () {
-  var path = "/weekly-earnings";
-  var config = {
-    screens: {
-      RootTabs: {
-        screens: {
-          HomeTab: {
-            screens: {
-              Home: "",
-              WeeklyEarnings: "weekly-earnings",
-              EventDetails: "event-details/:eventId"
-            }
-          },
-          EarningsTab: {
-            initialRouteName: "Earnings",
-            path: "earnings",
-            screens: {
-              Earnings: "",
-              WeeklyEarnings: "weekly-earnings"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "RootTabs",
-      key: "RootTabs-0",
-      state: {
-        routes: [{
-          name: "HomeTab",
-          key: "HomeTab-1",
-          state: {
-            routes: [{
-              name: "WeeklyEarnings",
-              key: "WeeklyEarnings-2",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test("correctly applies initialRouteName for config with similar route names v2", function () {
-  var path = "/earnings/weekly-earnings";
-  var config = {
-    screens: {
-      RootTabs: {
-        screens: {
-          HomeTab: {
-            initialRouteName: "Home",
-            screens: {
-              Home: "",
-              WeeklyEarnings: "weekly-earnings"
-            }
-          },
-          EarningsTab: {
-            initialRouteName: "Earnings",
-            path: "earnings",
-            screens: {
-              Earnings: "",
-              WeeklyEarnings: "weekly-earnings"
-            }
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "RootTabs",
-      key: "RootTabs-0",
-      state: {
-        routes: [{
-          name: "EarningsTab",
-          key: "EarningsTab-1",
-          state: {
-            index: 1,
-            routes: [{
-              name: "Earnings",
-              key: "Earnings-2"
-            }, {
-              name: "WeeklyEarnings",
-              key: "WeeklyEarnings-3",
-              path
-            }]
-          }
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-  expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
-});
-test.skip("throws when invalid properties are specified in the config", function () {
-  expect(function () {
-    return 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."
-  `);
-  expect(function () {
-    return 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."
-`);
-  expect(function () {
-    return getStateFromPath("", {
-      path: "foo/:id"
-    });
-  }).toThrowErrorMatchingInlineSnapshot(`"Found invalid path 'foo/:id'. The 'path' in the top-level configuration cannot contain patterns for params."`);
-});
-test.skip("encodes special characters in params", function () {
-  var paramWithValidSymbols = `User09-A_Z~!$&'()*+,;=:@__`;
-  var invalidSymbols = "#?[]{}%<>||";
-  var queryString = "user#email@gmail.com=2&4";
-  var path = `users/id/${paramWithValidSymbols}${encodeURIComponent(invalidSymbols)}?query=${encodeURIComponent(queryString)}`;
-  var config = {
-    path: "users",
-    screens: {
-      Users: {
-        screens: {
-          User: "id/:id"
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Users",
-      state: {
-        routes: [{
-          name: "User",
-          params: {
-            id: `${paramWithValidSymbols}${invalidSymbols}`,
-            query: queryString
-          }
-        }]
-      }
-    }]
-  };
-  expect(getPathFromState(state, config)).toBe(`/${path}`);
-  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(`/${path}`);
-});
-test.skip("resolves nested path params with same name to correct screen", function () {
-  var path = "/foo/42/bar/43";
-  var config = {
-    initialRouteName: "Foo",
-    screens: {
-      Foo: {
-        path: "foo/:id",
-        screens: {
-          Bar: {
-            path: "bar/:id"
-          }
-        }
-      }
-    }
-  };
-  var state = {
-    routes: [{
-      name: "Foo",
-      params: {
-        id: "42"
-      },
-      state: {
-        routes: [{
-          name: "Bar",
-          params: {
-            id: "43"
-          },
-          path
-        }]
-      }
-    }]
-  };
-  expect(getStateFromPath(path, config)).toEqual(state);
-});
-test("parses / same as empty string", function () {
-  var config = {
-    screens: {
-      Foo: {
-        path: "/"
-      },
-      Bar: {
-        path: "bar"
-      }
-    }
-  };
-  expect(getStateFromPath("/", config)).toEqual(getStateFromPath("", config));
-});
-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/*"
-      }
-    }
-  };
-  expect(getStateFromPath("foo/42", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      params: {
-        id: 42
-      },
-      path: "foo/42"
-    }]
-  });
-  expect(getStateFromPath("foo/bar", config)).toEqual({
-    routes: [{
-      name: "Bar",
-      params: {
-        id: "bar"
-      },
-      path: "foo/bar"
-    }]
-  });
-  expect(getStateFromPath("foo/42/bar", config)).toEqual({
-    routes: [{
-      name: "Baz",
-      params: {
-        id: "42",
-        name: "bar"
-      },
-      path: "foo/42/bar"
-    }]
-  });
-  expect(getStateFromPath("foo/@bar", config)).toEqual({
-    routes: [{
-      name: "Qux",
-      params: {
-        id: "bar"
-      },
-      path: "foo/@bar"
-    }]
-  });
-  expect(getStateFromPath("foo/@bar", config)).toEqual({
-    routes: [{
-      name: "Qux",
-      params: {
-        id: "bar"
-      },
-      path: "foo/@bar"
-    }]
-  });
-  expect(getStateFromPath("foo/42a", config)).toBeUndefined();
-  expect(getStateFromPath("foo/bar/123", config)).toEqual({
-    routes: [{
-      name: "Quy",
-      params: {
-        category: "123"
-      },
-      path: "foo/bar/123"
-    }]
-  });
-  expect(getStateFromPath("foo/bar/test", config)).toEqual({
-    routes: [{
-      name: "Quz",
-      params: {
-        special: "test"
-      },
-      path: "foo/bar/test"
-    }]
-  });
-  expect(getStateFromPath("foo/bar/baz", config)).toEqual({
-    routes: [{
-      name: "Quu",
-      path: "foo/bar/baz"
-    }]
-  });
-  expect(getStateFromPath("foo/bar/hello/world", config)).toEqual({
-    routes: [{
-      name: "NotFound",
-      path: "foo/bar/hello/world"
-    }]
-  });
-});
-test("regexp pattern doesn't match slash", function () {
-  var config = {
-    screens: {
-      Foo: {
-        path: "foo/:id([a-z]+\\/)"
-      }
-    }
-  };
-  expect(getStateFromPath("foo/bar/", config)).toBeUndefined();
-  expect(getStateFromPath("foo/bar/baz", config)).toBeUndefined();
-  expect(getStateFromPath("foo/bar/baz/qux", config)).toBeUndefined();
-});
-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: true
-            }, "third", {
-              path: "fourth/:id",
-              parse: {
-                id: function (value) {
-                  return value.replace(/\$/, "");
-                }
-              }
-            }]
-          },
-          Qux: {
-            path: "qux/:id"
-          }
-        }
-      }
-    }
-  };
-  expect(getStateFromPath("foo", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      path: "foo"
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("foo", config), config)).toBe("/foo");
-  expect(getStateFromPath("first", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      path: "first"
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("first", config), config)).toBe("/foo");
-  expect(getStateFromPath("foo/baz/@$test", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Baz",
-          params: {
-            id: "$test"
-          },
-          path: "foo/baz/@$test"
-        }]
-      }
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("foo/baz/@$test", config), config)).toBe("/foo/baz/$test");
-  expect(getStateFromPath("second/42", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Baz",
-          params: {
-            id: "42"
-          },
-          path: "second/42"
-        }]
-      }
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("second/42", config), config)).toBe("/foo/baz/42");
-  expect(getStateFromPath("foo/third", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Baz",
-          path: "foo/third"
-        }]
-      }
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("foo/third", config), config)).toBe("/foo/baz");
-  expect(getStateFromPath("foo/fourth/@$test", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Baz",
-          params: {
-            id: "@test"
-          },
-          path: "foo/fourth/@$test"
-        }]
-      }
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("foo/fourth/@$test", config), config)).toBe("/foo/baz/@test");
-  expect(getStateFromPath("foo/qux/42", config)).toEqual({
-    routes: [{
-      name: "Foo",
-      state: {
-        routes: [{
-          name: "Qux",
-          params: {
-            id: "42"
-          },
-          path: "foo/qux/42"
-        }]
-      }
-    }]
-  });
-  expect(getPathFromState(getStateFromPath("foo/qux/42", config), config)).toBe("/foo/qux/42");
-});
-test.skip("throws if screen has alias but no path", function () {
-  expect(function () {
-    return 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.native.js.map