one 1.14.4 → 1.15.0

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

@@ -13,114 +13,116 @@ 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",
-    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"));
+  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",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Bar: {
-              path: "/bar/:id"
-            }
+  var path = "/foo/bar/bar_%23_foo";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Bar: {
+            path: "/bar/:id"
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Bar: {
-              path: "/bar/:id"
-            }
+  var path = "/foo/bar/bar_%2F_foo";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Bar: {
+            path: "/bar/:id"
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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
+  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();
+                    });
                   },
-                  stringify: {
-                    author: function (author) {
-                      return author.toLowerCase();
-                    }
+                  count: Number,
+                  valid: Boolean
+                },
+                stringify: {
+                  author: function (author) {
+                    return author.toLowerCase();
                   }
                 }
               }
@@ -128,34 +130,36 @@ test.skip("converts path string to initial state with config", function () {
           }
         }
       }
-    },
-    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
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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";
@@ -196,51 +200,51 @@ test("handles ending slash when converting", function () {
   });
 });
 test("handles route without param", function () {
-  var path = "foo/bar",
-    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"));
+  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",
-    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
+  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();
+                        });
                       },
-                      stringify: {
-                        author: function (author) {
-                          return author.toLowerCase();
-                        }
+                      count: Number,
+                      valid: Boolean
+                    },
+                    stringify: {
+                      author: function (author) {
+                        return author.toLowerCase();
                       }
                     }
                   }
@@ -250,130 +254,132 @@ test.skip("converts path string to initial state with config with nested screens
           }
         }
       }
-    },
-    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
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    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
-                  }
+  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
                 }
               }
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Foe",
-            state: {
-              routes: [{
-                name: "Baz",
-                params: {
-                  author: "Jane",
-                  count: 10,
-                  answer: "42",
-                  valid: !0
-                },
-                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"));
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              screens: {
-                Foe: {
-                  path: "foe",
-                  screens: {
-                    Baz: {
-                      screens: {
-                        Bos: {
-                          path: "bos",
-                          exact: !0
+  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();
+                            });
+                          }
                         },
-                        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();
+                            });
                           },
-                          parse: {
-                            author: function (author) {
-                              return author.replace(/^\w/, function (c) {
-                                return c.toUpperCase();
-                              });
-                            },
-                            count: Number,
-                            valid: Boolean
-                          }
+                          count: Number,
+                          valid: Boolean
                         }
                       }
                     }
@@ -384,327 +390,334 @@ test.skip("handles nested object with unused configs and with parse in it", func
           }
         }
       }
-    },
-    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
-                      }]
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Foe: {
-              path: "foe",
-              exact: !0
-            },
-            Bar: {
-              path: "bar",
-              exact: !0,
-              screens: {
-                Baz: {
-                  path: "baz",
-                  exact: !0
-                }
+  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
               }
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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
-                }
+  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
               }
             }
           }
         }
       }
-    },
-    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",
-    config = {
-      path: "foo",
-      screens: {
-        Foo: {
-          screens: {
-            Fruits: "fruits/:fruit"
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      key: "Foo-0",
+      state: {
+        routes: [{
+          name: "Bar",
+          key: "Bar-1",
+          state: {
+            routes: [{
+              name: "Baz",
+              key: "Baz-2",
+              path
+            }]
           }
-        }
+        }]
       }
-    },
-    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.skip("handles path at top level", function () {
+  var path = "/foo/fruits/apple";
+  var config = {
+    path: "foo",
+    screens: {
+      Foo: {
+        screens: {
+          Fruits: "fruits/:fruit"
         }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+      }
+    }
+  };
+  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",
-    config = {
-      initialRouteName: "Boo",
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Baz: "baz"
-              }
+  var path = "/baz";
+  var config = {
+    initialRouteName: "Boo",
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            screens: {
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          initialRouteName: "Foe",
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Baz: "baz"
-              }
+  var path = "/baz";
+  var config = {
+    screens: {
+      Foo: {
+        initialRouteName: "Foe",
+        screens: {
+          Foe: "foe",
+          Bar: {
+            screens: {
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    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",
-    config = {
-      screens: {
-        Foo: {
-          initialRouteName: "Foe",
-          screens: {
-            Foe: {
-              screens: {
-                Baz: "baz"
-              }
-            },
-            Bar: "bar"
+    }
+  };
+  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
+            }]
           }
-        }
+        }]
       }
-    },
-    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("handles initialRouteName included in path", function () {
+  var path = "/baz";
+  var config = {
+    screens: {
+      Foo: {
+        initialRouteName: "Foe",
+        screens: {
+          Foe: {
+            screens: {
+              Baz: "baz"
             }
-          }]
+          },
+          Bar: "bar"
         }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+      }
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              screens: {
-                Foe: {
-                  path: "foe",
-                  screens: {
-                    Baz: {
-                      initialRouteName: "Bos",
-                      screens: {
-                        Bos: {
-                          path: "bos",
-                          exact: !0
+  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();
+                            });
+                          }
                         },
-                        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();
+                            });
                           },
-                          parse: {
-                            author: function (author) {
-                              return author.replace(/^\w/, function (c) {
-                                return c.toUpperCase();
-                              });
-                            },
-                            count: Number,
-                            valid: Boolean
-                          }
+                          count: Number,
+                          valid: Boolean
                         }
                       }
                     }
@@ -715,85 +728,86 @@ test.skip("handles two initialRouteNames", function () {
           }
         }
       }
-    },
-    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
-                      }]
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              screens: {
-                Foe: {
-                  path: "foe",
-                  screens: {
-                    Baz: {
-                      initialRouteName: "Bas",
-                      screens: {
-                        Bos: {
-                          path: "bos",
-                          exact: !0
+  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();
+                            });
+                          }
                         },
-                        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();
+                            });
                           },
-                          parse: {
-                            author: function (author) {
-                              return author.replace(/^\w/, function (c) {
-                                return c.toUpperCase();
-                              });
-                            },
-                            count: Number,
-                            valid: Boolean
-                          }
+                          count: Number,
+                          valid: Boolean
                         }
                       }
                     }
@@ -804,1368 +818,1400 @@ test.skip("accepts initialRouteName without config for it", function () {
           }
         }
       }
-    },
-    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
-                      }]
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    config = {
-      path: "qux",
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foo",
-            Bar: {
-              screens: {
-                Baz: "bar"
-              }
+  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",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Baz: "baz"
-              }
+  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 = "",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Baz: "baz"
-              }
+  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 = "",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Qux: "",
-                Baz: "baz"
-              }
+  var path = "";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            screens: {
+              Qux: "",
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    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, ""));
+    }
+  };
+  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 = "/",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Qux: "",
-                Baz: "baz"
-              }
+  var path = "/";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            screens: {
+              Qux: "",
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    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, ""));
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Qux: {
-                  path: "",
-                  parse: {
-                    foo: Number
-                  }
-                },
-                Baz: "baz"
-              }
+  var path = "?foo=42";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            screens: {
+              Qux: {
+                path: "",
+                parse: {
+                  foo: Number
+                }
+              },
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    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"));
+    }
+  };
+  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
-                  }
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            path: "bar",
+            screens: {
+              Qux: {
+                path: "",
+                parse: {
+                  foo: Number
                 }
               }
             }
           }
         }
       }
-    },
-    path = "";
+    }
+  };
+  var path = "";
   expect(getStateFromPath(path, config)).toBeUndefined();
 });
 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
-              }
+  var path = "/foo/5";
+  var 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
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foe: {
-          path: "/",
-          initialRouteName: "Foo",
-          screens: {
-            Foo: "foo",
-            Bis: {
-              path: "foos"
-            }
+  var path = "/foos";
+  var config = {
+    screens: {
+      Foe: {
+        path: "/",
+        initialRouteName: "Foo",
+        screens: {
+          Foo: "foo",
+          Bis: {
+            path: "foos"
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foe: {
-          path: "/",
-          initialRouteName: "Foo",
-          screens: {
-            Foo: "foo",
-            Bis: {
-              path: "foos/:id",
-              parse: {
-                id: Number
-              }
+  var path = "/foos/5";
+  var 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
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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"));
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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"));
+    }
+  };
+  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",
-    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 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
             }
           }
         }
       }
-    },
-    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",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo/:bar",
-          parse: {
-            bar: Number
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foe",
+      state: {
+        index: 1,
+        routes: [{
+          name: "Foo"
+        }, {
+          name: "Bas",
+          params: {
+            nip: 5,
+            pwd: 10,
+            id: 15
           },
-          screens: {
-            Baz: "baz/:qux"
-          }
-        }
+          path
+        }]
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        params: {
-          bar: 42
+    }]
+  };
+  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
         },
-        state: {
-          routes: [{
-            name: "Baz",
-            params: {
-              qux: "babel"
-            },
-            path
-          }]
+        screens: {
+          Baz: "baz/:qux"
         }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/foo/42/baz/babel"));
+      }
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar//:id/"
-            }
+  var path = "/bar/42";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Bar: {
+            path: "/bar//:id/"
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        404: "*",
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/"
+  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: "*"
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "404",
-        path
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/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", function () {
-  var path = "/bar/42/whatever/baz/initt",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                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: {}
         }
       }
-    },
-    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",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                404: {
-                  path: "*",
-                  exact: !0
-                }
-              }
-            },
-            Baz: {}
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "404",
+              path
+            }]
           }
-        }
+        }]
       }
-    },
-    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"));
+    }]
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                404: "*",
-                UserProfile: ":userSlug",
-                Test: "test"
-              }
+  var path = "/bar/42/test";
+  var 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
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(state);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                Baz: "baz"
-              }
-            },
-            404: "*"
-          }
+  var path = "/bar/42/baz/test";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Bar: {
+            path: "/bar/:id/",
+            screens: {
+              Baz: "baz"
+            }
+          },
+          404: "*"
         }
       }
-    },
-    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"));
+    }
+  };
+  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",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                Baz: "baz"
-              }
-            },
-            Baz: "/bar/:id/*"
-          }
+  var path = "/bar/42/baz/test/whatever";
+  var 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
-          }]
-        }
-      }]
-    };
-  expect(getStateFromPath(path, config)).toEqual(state), expect(getStateFromPath(getPathFromState(state, config), config)).toEqual(changePath(state, "/bar/42/Baz"));
+    }
+  };
+  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";
@@ -2185,7 +2231,8 @@ test("throws if two screens map to the same pattern", function () {
         }
       }
     });
-  }).toThrow("Found conflicting screens with the same pattern. The pattern 'bar/:id/baz' resolves to both 'Foo > Bax' and 'Foo > Bar > Baz'. Patterns must be unique and cannot resolve to more than one screen."), expect(function () {
+  }).toThrow("Found conflicting screens with the same pattern. The pattern 'bar/:id/baz' resolves to both 'Foo > Bax' and 'Foo > Bar > Baz'. Patterns must be unique and cannot resolve to more than one screen.");
+  expect(function () {
     return getStateFromPath(path, {
       screens: {
         Foo: {
@@ -2203,100 +2250,102 @@ test("throws if two screens map to the same pattern", function () {
   }).not.toThrow();
 });
 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"
-              }
+  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"
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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",
-    config = {
-      screens: {
-        RootTabs: {
-          screens: {
-            HomeTab: {
-              initialRouteName: "Home",
-              screens: {
-                Home: "",
-                WeeklyEarnings: "weekly-earnings"
-              }
-            },
-            EarningsTab: {
-              initialRouteName: "Earnings",
-              path: "earnings",
-              screens: {
-                Earnings: "",
-                WeeklyEarnings: "weekly-earnings"
-              }
+  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"
             }
           }
         }
       }
-    },
-    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);
+    }
+  };
+  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 () {
@@ -2321,7 +2370,8 @@ test.skip("throws when invalid properties are specified in the config", function
     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 () {
+  `);
+  expect(function () {
     return getStateFromPath("", {
       screens: {
         Foo: "foo",
@@ -2351,75 +2401,77 @@ You can only specify the following properties:
 If you want to specify configuration for screens, you need to specify them under a 'screens' property.
 
 See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration."
-`), expect(function () {
+`);
+  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~!$&'()*+,;=:@__",
-    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"
-          }
+  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"
         }
       }
-    },
-    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}`);
+    }
+  };
+  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",
-    config = {
-      initialRouteName: "Foo",
-      screens: {
-        Foo: {
-          path: "foo/:id",
-          screens: {
-            Bar: {
-              path: "bar/:id"
-            }
+  var path = "/foo/42/bar/43";
+  var 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
-          }]
-        }
-      }]
-    };
+    }
+  };
+  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 () {
@@ -2480,7 +2532,8 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/42"
     }]
-  }), expect(getStateFromPath("foo/bar", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/bar", config)).toEqual({
     routes: [{
       name: "Bar",
       params: {
@@ -2488,7 +2541,8 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/bar"
     }]
-  }), expect(getStateFromPath("foo/42/bar", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/42/bar", config)).toEqual({
     routes: [{
       name: "Baz",
       params: {
@@ -2497,7 +2551,8 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/42/bar"
     }]
-  }), expect(getStateFromPath("foo/@bar", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/@bar", config)).toEqual({
     routes: [{
       name: "Qux",
       params: {
@@ -2505,7 +2560,8 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/@bar"
     }]
-  }), expect(getStateFromPath("foo/@bar", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/@bar", config)).toEqual({
     routes: [{
       name: "Qux",
       params: {
@@ -2513,7 +2569,9 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/@bar"
     }]
-  }), expect(getStateFromPath("foo/42a", config)).toBeUndefined(), expect(getStateFromPath("foo/bar/123", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/42a", config)).toBeUndefined();
+  expect(getStateFromPath("foo/bar/123", config)).toEqual({
     routes: [{
       name: "Quy",
       params: {
@@ -2521,7 +2579,8 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/bar/123"
     }]
-  }), expect(getStateFromPath("foo/bar/test", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/bar/test", config)).toEqual({
     routes: [{
       name: "Quz",
       params: {
@@ -2529,12 +2588,14 @@ test.skip("matches regexp patterns when provided", function () {
       },
       path: "foo/bar/test"
     }]
-  }), expect(getStateFromPath("foo/bar/baz", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/bar/baz", config)).toEqual({
     routes: [{
       name: "Quu",
       path: "foo/bar/baz"
     }]
-  }), expect(getStateFromPath("foo/bar/hello/world", config)).toEqual({
+  });
+  expect(getStateFromPath("foo/bar/hello/world", config)).toEqual({
     routes: [{
       name: "NotFound",
       path: "foo/bar/hello/world"
@@ -2549,7 +2610,9 @@ test("regexp pattern doesn't match slash", function () {
       }
     }
   };
-  expect(getStateFromPath("foo/bar/", config)).toBeUndefined(), expect(getStateFromPath("foo/bar/baz", config)).toBeUndefined(), expect(getStateFromPath("foo/bar/baz/qux", config)).toBeUndefined();
+  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 = {
@@ -2567,7 +2630,7 @@ test.skip("handles alias for paths", function () {
             },
             alias: [{
               path: "second/:id",
-              exact: !0
+              exact: true
             }, "third", {
               path: "fourth/:id",
               parse: {
@@ -2589,12 +2652,16 @@ test.skip("handles alias for paths", function () {
       name: "Foo",
       path: "foo"
     }]
-  }), expect(getPathFromState(getStateFromPath("foo", config), config)).toBe("/foo"), expect(getStateFromPath("first", config)).toEqual({
+  });
+  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({
+  });
+  expect(getPathFromState(getStateFromPath("first", config), config)).toBe("/foo");
+  expect(getStateFromPath("foo/baz/@$test", config)).toEqual({
     routes: [{
       name: "Foo",
       state: {
@@ -2607,7 +2674,9 @@ test.skip("handles alias for paths", function () {
         }]
       }
     }]
-  }), expect(getPathFromState(getStateFromPath("foo/baz/@$test", config), config)).toBe("/foo/baz/$test"), expect(getStateFromPath("second/42", config)).toEqual({
+  });
+  expect(getPathFromState(getStateFromPath("foo/baz/@$test", config), config)).toBe("/foo/baz/$test");
+  expect(getStateFromPath("second/42", config)).toEqual({
     routes: [{
       name: "Foo",
       state: {
@@ -2620,7 +2689,9 @@ test.skip("handles alias for paths", function () {
         }]
       }
     }]
-  }), expect(getPathFromState(getStateFromPath("second/42", config), config)).toBe("/foo/baz/42"), expect(getStateFromPath("foo/third", config)).toEqual({
+  });
+  expect(getPathFromState(getStateFromPath("second/42", config), config)).toBe("/foo/baz/42");
+  expect(getStateFromPath("foo/third", config)).toEqual({
     routes: [{
       name: "Foo",
       state: {
@@ -2630,7 +2701,9 @@ test.skip("handles alias for paths", function () {
         }]
       }
     }]
-  }), expect(getPathFromState(getStateFromPath("foo/third", config), config)).toBe("/foo/baz"), expect(getStateFromPath("foo/fourth/@$test", config)).toEqual({
+  });
+  expect(getPathFromState(getStateFromPath("foo/third", config), config)).toBe("/foo/baz");
+  expect(getStateFromPath("foo/fourth/@$test", config)).toEqual({
     routes: [{
       name: "Foo",
       state: {
@@ -2643,7 +2716,9 @@ test.skip("handles alias for paths", function () {
         }]
       }
     }]
-  }), expect(getPathFromState(getStateFromPath("foo/fourth/@$test", config), config)).toBe("/foo/baz/@test"), expect(getStateFromPath("foo/qux/42", config)).toEqual({
+  });
+  expect(getPathFromState(getStateFromPath("foo/fourth/@$test", config), config)).toBe("/foo/baz/@test");
+  expect(getStateFromPath("foo/qux/42", config)).toEqual({
     routes: [{
       name: "Foo",
       state: {
@@ -2656,7 +2731,8 @@ test.skip("handles alias for paths", function () {
         }]
       }
     }]
-  }), expect(getPathFromState(getStateFromPath("foo/qux/42", config), config)).toBe("/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 () {
@@ -2667,6 +2743,6 @@ test.skip("throws if screen has alias but no path", function () {
         }
       }
     });
-  }).toThrow("Screen 'Foo' doesn't specify a 'path'. A 'path' needs to be specified in order to use 'alias'.");
+  }).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