one 1.14.4 → 1.15.0

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

@@ -3,63 +3,63 @@ import { getPathFromState } from "../getPathFromState.native.js";
 import { getStateFromPath } from "../getStateFromPath.native.js";
 test("converts state to path string", function () {
   var state = {
-      routes: [{
-        name: "foo",
-        state: {
-          index: 1,
-          routes: [{
-            name: "boo"
-          }, {
-            name: "bar",
-            params: {
-              fruit: "apple"
-            },
-            state: {
-              routes: [{
-                name: "baz qux",
-                params: {
-                  author: "jane",
-                  valid: !0
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    },
-    path = "/foo/bar/baz%20qux?author=jane&valid=true";
-  expect(getPathFromState(state)).toBe(path), expect(getPathFromState(getStateFromPath(path))).toBe(path);
+    routes: [{
+      name: "foo",
+      state: {
+        index: 1,
+        routes: [{
+          name: "boo"
+        }, {
+          name: "bar",
+          params: {
+            fruit: "apple"
+          },
+          state: {
+            routes: [{
+              name: "baz qux",
+              params: {
+                author: "jane",
+                valid: true
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  var path = "/foo/bar/baz%20qux?author=jane&valid=true";
+  expect(getPathFromState(state)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path))).toBe(path);
 });
 test("converts state to path string with config", function () {
-  var path = "/few/bar/sweet/apple/baz/jane?id=x10&valid=true",
-    config = {
-      screens: {
-        Foo: {
-          path: "few",
-          screens: {
-            Bar: {
-              path: "bar/:type/:fruit",
-              screens: {
-                Baz: {
-                  path: "baz/:author",
-                  parse: {
-                    author: function (author) {
-                      return author.replace(/^\w/, function (c) {
-                        return c.toUpperCase();
-                      });
-                    },
-                    id: function (id) {
-                      return Number(id.replace(/^x/, ""));
-                    },
-                    valid: Boolean
+  var path = "/few/bar/sweet/apple/baz/jane?id=x10&valid=true";
+  var config = {
+    screens: {
+      Foo: {
+        path: "few",
+        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();
-                    },
-                    id: function (id) {
-                      return `x${id}`;
-                    }
+                  id: function (id) {
+                    return Number(id.replace(/^x/, ""));
+                  },
+                  valid: Boolean
+                },
+                stringify: {
+                  author: function (author) {
+                    return author.toLowerCase();
+                  },
+                  id: function (id) {
+                    return `x${id}`;
                   }
                 }
               }
@@ -67,36 +67,38 @@ test("converts state to path string with config", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          index: 1,
-          routes: [{
-            name: "boo"
-          }, {
-            name: "Bar",
-            params: {
-              fruit: "apple",
-              type: "sweet",
-              avaliable: !1
-            },
-            state: {
-              routes: [{
-                name: "Baz",
-                params: {
-                  author: "Jane",
-                  id: 10,
-                  valid: !0
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        index: 1,
+        routes: [{
+          name: "boo"
+        }, {
+          name: "Bar",
+          params: {
+            fruit: "apple",
+            type: "sweet",
+            avaliable: false
+          },
+          state: {
+            routes: [{
+              name: "Baz",
+              params: {
+                author: "Jane",
+                id: 10,
+                valid: true
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("prepends trailing slash to path", function () {
   expect(getPathFromState({
@@ -108,7 +110,8 @@ test("prepends trailing slash to path", function () {
         }]
       }
     }]
-  })).toBe("/foo/bar"), expect(getPathFromState({
+  })).toBe("/foo/bar");
+  expect(getPathFromState({
     routes: [{
       name: "foo",
       state: {
@@ -121,63 +124,64 @@ test("prepends trailing slash to path", function () {
   })).toBe("/foo/bar");
 });
 test("handles route without param", function () {
-  var path = "/foo/bar",
-    state = {
-      routes: [{
-        name: "foo",
-        state: {
-          routes: [{
-            name: "bar"
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state)).toBe(path), expect(getPathFromState(getStateFromPath(path))).toBe(path);
+  var path = "/foo/bar";
+  var state = {
+    routes: [{
+      name: "foo",
+      state: {
+        routes: [{
+          name: "bar"
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path))).toBe(path);
 });
 test("doesn't add query param for empty params", function () {
-  var path = "/foo",
-    state = {
-      routes: [{
-        name: "foo",
-        params: {}
-      }]
-    };
-  expect(getPathFromState(state)).toBe(path), expect(getPathFromState(getStateFromPath(path))).toBe(path);
+  var path = "/foo";
+  var state = {
+    routes: [{
+      name: "foo",
+      params: {}
+    }]
+  };
+  expect(getPathFromState(state)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path))).toBe(path);
 });
 test("handles state with config with nested screens", function () {
-  var path = "/foo/foe/bar/sweet/apple/baz/jane?answer=42&count=10&valid=true",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Foe: {
-              path: "foe",
-              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/foe/bar/sweet/apple/baz/jane?answer=42&count=10&valid=true";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Foe: {
+            path: "foe",
+            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();
-                        },
-                        id: function (id) {
-                          return `x${id}`;
-                        },
-                        unknown: function (_) {
-                          return "x";
-                        }
+                      count: Number,
+                      valid: Boolean
+                    },
+                    stringify: {
+                      author: function (author) {
+                        return author.toLowerCase();
+                      },
+                      id: function (id) {
+                        return `x${id}`;
+                      },
+                      unknown: function (_) {
+                        return "x";
                       }
                     }
                   }
@@ -187,74 +191,75 @@ test("handles state with config with nested screens", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Foe",
-            state: {
-              routes: [{
-                name: "Bar",
-                params: {
-                  fruit: "apple",
-                  type: "sweet"
-                },
-                state: {
-                  routes: [{
-                    name: "Baz",
-                    params: {
-                      answer: "42",
-                      author: "Jane",
-                      count: "10",
-                      valid: !0
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Foe",
+          state: {
+            routes: [{
+              name: "Bar",
+              params: {
+                fruit: "apple",
+                type: "sweet"
+              },
+              state: {
+                routes: [{
+                  name: "Baz",
+                  params: {
+                    answer: "42",
+                    author: "Jane",
+                    count: "10",
+                    valid: true
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles state with config with nested screens and exact", function () {
-  var path = "/foe/bar/sweet/apple/baz/jane?answer=42&count=10&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?answer=42&count=10&valid=true";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Foe: {
+            path: "foe",
+            exact: true,
+            screens: {
+              Bar: {
+                path: "bar/:type/:fruit",
+                screens: {
+                  Baz: {
+                    path: "baz/:author",
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
+                    },
+                    stringify: {
+                      author: function (author) {
+                        return author.toLowerCase();
                       },
-                      stringify: {
-                        author: function (author) {
-                          return author.toLowerCase();
-                        },
-                        id: function (id) {
-                          return `x${id}`;
-                        },
-                        unknown: function (_) {
-                          return "x";
-                        }
+                      id: function (id) {
+                        return `x${id}`;
+                      },
+                      unknown: function (_) {
+                        return "x";
                       }
                     }
                   }
@@ -264,69 +269,70 @@ test("handles state with config with nested screens and exact", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Foe",
-            state: {
-              routes: [{
-                name: "Bar",
-                params: {
-                  fruit: "apple",
-                  type: "sweet"
-                },
-                state: {
-                  routes: [{
-                    name: "Baz",
-                    params: {
-                      answer: "42",
-                      author: "Jane",
-                      count: "10",
-                      valid: !0
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Foe",
+          state: {
+            routes: [{
+              name: "Bar",
+              params: {
+                fruit: "apple",
+                type: "sweet"
+              },
+              state: {
+                routes: [{
+                  name: "Baz",
+                  params: {
+                    answer: "42",
+                    author: "Jane",
+                    count: "10",
+                    valid: true
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles state with config with nested screens and unused configs", function () {
-  var path = "/foo/foe/baz/jane?answer=42&count=10&valid=true",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Foe: {
-              path: "foe",
-              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/foe/baz/jane?answer=42&count=10&valid=true";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Foe: {
+            path: "foe",
+            screens: {
+              Baz: {
+                path: "baz/:author",
+                parse: {
+                  author: function (author) {
+                    return author.replace(/^\w/, function (c) {
+                      return c.toUpperCase();
+                    });
                   },
-                  stringify: {
-                    author: function (author) {
-                      return author.replace(/^\w/, function (c) {
-                        return c.toLowerCase();
-                      });
-                    },
-                    unknown: function (_) {
-                      return "x";
-                    }
+                  count: Number,
+                  valid: Boolean
+                },
+                stringify: {
+                  author: function (author) {
+                    return author.replace(/^\w/, function (c) {
+                      return c.toLowerCase();
+                    });
+                  },
+                  unknown: function (_) {
+                    return "x";
                   }
                 }
               }
@@ -334,61 +340,62 @@ test("handles state with config with nested screens and unused configs", functio
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Foe",
-            state: {
-              routes: [{
-                name: "Baz",
-                params: {
-                  answer: "42",
-                  author: "Jane",
-                  count: 10,
-                  valid: !0
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Foe",
+          state: {
+            routes: [{
+              name: "Baz",
+              params: {
+                answer: "42",
+                author: "Jane",
+                count: 10,
+                valid: true
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles state with config with nested screens and unused configs with exact", function () {
-  var path = "/foe/baz/jane?answer=42&count=10&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
+  var path = "/foe/baz/jane?answer=42&count=10&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();
+                    });
                   },
-                  stringify: {
-                    author: function (author) {
-                      return author.replace(/^\w/, function (c) {
-                        return c.toLowerCase();
-                      });
-                    },
-                    unknown: function (_) {
-                      return "x";
-                    }
+                  count: Number,
+                  valid: Boolean
+                },
+                stringify: {
+                  author: function (author) {
+                    return author.replace(/^\w/, function (c) {
+                      return c.toLowerCase();
+                    });
+                  },
+                  unknown: function (_) {
+                    return "x";
                   }
                 }
               }
@@ -396,64 +403,65 @@ test("handles state with config with nested screens and unused configs with exac
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Foe",
-            state: {
-              routes: [{
-                name: "Baz",
-                params: {
-                  answer: "42",
-                  author: "Jane",
-                  count: 10,
-                  valid: !0
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Foe",
+          state: {
+            routes: [{
+              name: "Baz",
+              params: {
+                answer: "42",
+                author: "Jane",
+                count: 10,
+                valid: true
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles nested object with stringify in it", function () {
-  var path = "/bar/sweet/apple/foo/bis/jane?answer=42&count=10&valid=true",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              path: "foo",
-              screens: {
-                Foe: {
-                  path: "foe"
-                },
-                Baz: {
-                  screens: {
-                    Bos: "bos",
-                    Bis: {
-                      path: "bis/:author",
-                      stringify: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toLowerCase();
-                          });
-                        }
-                      },
-                      parse: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toUpperCase();
-                          });
-                        },
-                        count: Number,
-                        valid: Boolean
+  var path = "/bar/sweet/apple/foo/bis/jane?answer=42&count=10&valid=true";
+  var config = {
+    screens: {
+      Bar: {
+        path: "bar/:type/:fruit",
+        screens: {
+          Foo: {
+            path: "foo",
+            screens: {
+              Foe: {
+                path: "foe"
+              },
+              Baz: {
+                screens: {
+                  Bos: "bos",
+                  Bis: {
+                    path: "bis/:author",
+                    stringify: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toLowerCase();
+                        });
                       }
+                    },
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
                     }
                   }
                 }
@@ -462,75 +470,76 @@ test("handles nested object with stringify in it", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple",
-          type: "sweet"
-        },
-        state: {
-          routes: [{
-            name: "Foo",
-            state: {
-              routes: [{
-                name: "Baz",
-                state: {
-                  routes: [{
-                    name: "Bis",
-                    params: {
-                      answer: "42",
-                      author: "Jane",
-                      count: 10,
-                      valid: !0
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple",
+        type: "sweet"
+      },
+      state: {
+        routes: [{
+          name: "Foo",
+          state: {
+            routes: [{
+              name: "Baz",
+              state: {
+                routes: [{
+                  name: "Bis",
+                  params: {
+                    answer: "42",
+                    author: "Jane",
+                    count: 10,
+                    valid: true
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles nested object with stringify in it with exact", function () {
-  var path = "/bis/jane?answer=42&count=10&valid=true",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              path: "foo",
-              screens: {
-                Foe: {
-                  path: "foe"
-                },
-                Baz: {
-                  path: "baz",
-                  screens: {
-                    Bos: "bos",
-                    Bis: {
-                      path: "bis/:author",
-                      exact: !0,
-                      stringify: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toLowerCase();
-                          });
-                        }
-                      },
-                      parse: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toUpperCase();
-                          });
-                        },
-                        count: Number,
-                        valid: Boolean
+  var path = "/bis/jane?answer=42&count=10&valid=true";
+  var config = {
+    screens: {
+      Bar: {
+        path: "bar/:type/:fruit",
+        screens: {
+          Foo: {
+            path: "foo",
+            screens: {
+              Foe: {
+                path: "foe"
+              },
+              Baz: {
+                path: "baz",
+                screens: {
+                  Bos: "bos",
+                  Bis: {
+                    path: "bis/:author",
+                    exact: true,
+                    stringify: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toLowerCase();
+                        });
                       }
+                    },
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
                     }
                   }
                 }
@@ -539,506 +548,519 @@ test("handles nested object with stringify in it with exact", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple",
-          type: "sweet"
-        },
-        state: {
-          routes: [{
-            name: "Foo",
-            state: {
-              routes: [{
-                name: "Baz",
-                state: {
-                  routes: [{
-                    name: "Bis",
-                    params: {
-                      answer: "42",
-                      author: "Jane",
-                      count: 10,
-                      valid: !0
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple",
+        type: "sweet"
+      },
+      state: {
+        routes: [{
+          name: "Foo",
+          state: {
+            routes: [{
+              name: "Baz",
+              state: {
+                routes: [{
+                  name: "Bis",
+                  params: {
+                    answer: "42",
+                    author: "Jane",
+                    count: 10,
+                    valid: true
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles nested object for second route depth", function () {
-  var path = "/foo/bar/baz",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Foe: "foe",
-            Bar: {
-              path: "bar",
-              screens: {
-                Baz: "baz"
-              }
+  var path = "/foo/bar/baz";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Foe: "foe",
+          Bar: {
+            path: "bar",
+            screens: {
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles nested object for second route depth with exact", function () {
-  var path = "/baz",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Foe: "foe",
-            Bar: {
-              path: "bar",
-              screens: {
-                Baz: {
-                  path: "baz",
-                  exact: !0
-                }
+  var path = "/baz";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Foe: "foe",
+          Bar: {
+            path: "bar",
+            screens: {
+              Baz: {
+                path: "baz",
+                exact: true
               }
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles nested object for second route depth and path and stringify in roots", function () {
-  var path = "/foo/dathomir/bar/42/baz",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo/:planet",
-          stringify: {
-            id: function (id) {
-              return `planet=${id}`;
-            }
-          },
-          screens: {
-            Foe: "foe",
-            Bar: {
-              path: "bar/:id",
-              parse: {
-                id: Number
-              },
-              screens: {
-                Baz: "baz"
-              }
-            }
+  var path = "/foo/dathomir/bar/42/baz";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo/:planet",
+        stringify: {
+          id: function (id) {
+            return `planet=${id}`;
           }
-        }
-      }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        params: {
-          planet: "dathomir"
         },
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz",
-                params: {
-                  id: 42
-                }
-              }]
+        screens: {
+          Foe: "foe",
+          Bar: {
+            path: "bar/:id",
+            parse: {
+              id: Number
+            },
+            screens: {
+              Baz: "baz"
             }
-          }]
+          }
         }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+      }
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      params: {
+        planet: "dathomir"
+      },
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz",
+              params: {
+                id: 42
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles nested object for second route depth and path and stringify in roots with exact", function () {
-  var path = "/baz",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo/:id",
-          stringify: {
-            id: function (id) {
-              return `id=${id}`;
-            }
-          },
-          screens: {
-            Foe: "foe",
-            Bar: {
-              path: "bar/:id",
-              stringify: {
-                id: function (id) {
-                  return `id=${id}`;
-                }
-              },
-              parse: {
-                id: Number
-              },
-              screens: {
-                Baz: {
-                  path: "baz",
-                  exact: !0
-                }
+  var path = "/baz";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo/:id",
+        stringify: {
+          id: function (id) {
+            return `id=${id}`;
+          }
+        },
+        screens: {
+          Foe: "foe",
+          Bar: {
+            path: "bar/:id",
+            stringify: {
+              id: function (id) {
+                return `id=${id}`;
+              }
+            },
+            parse: {
+              id: Number
+            },
+            screens: {
+              Baz: {
+                path: "baz",
+                exact: true
               }
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("ignores empty string paths", function () {
-  var path = "/bar",
-    config = {
-      screens: {
-        Foo: {
-          path: "",
-          screens: {
-            Foe: "foe"
-          }
-        },
-        Bar: "bar"
-      }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar"
-          }]
+  var path = "/bar";
+  var config = {
+    screens: {
+      Foo: {
+        path: "",
+        screens: {
+          Foe: "foe"
         }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+      },
+      Bar: "bar"
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar"
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("keeps query 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",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Qux",
-                params: {
-                  foo: 42
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toEqual(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Qux",
+              params: {
+                foo: 42
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toEqual(path);
 });
 test("does not use Object.prototype properties as parsing functions", function () {
-  var path = "/?toString=42",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Foe: "foe",
-            Bar: {
-              screens: {
-                Qux: {
-                  path: "",
-                  parse: {}
-                },
-                Baz: "baz"
-              }
+  var path = "/?toString=42";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Foe: "foe",
+          Bar: {
+            screens: {
+              Qux: {
+                path: "",
+                parse: {}
+              },
+              Baz: "baz"
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Qux",
-                params: {
-                  toString: 42
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toEqual(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Qux",
+              params: {
+                toString: 42
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toEqual(path);
 });
 test("cuts nested configs too", function () {
-  var path = "/foo/baz",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Bar: {
-              path: "",
-              screens: {
-                Baz: {
-                  path: "baz"
-                }
+  var path = "/foo/baz";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Bar: {
+            path: "",
+            screens: {
+              Baz: {
+                path: "baz"
               }
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("cuts nested configs too with exact", function () {
-  var path = "/baz",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Bar: {
-              path: "",
-              exact: !0,
-              screens: {
-                Baz: {
-                  path: "baz"
-                }
+  var path = "/baz";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Bar: {
+            path: "",
+            exact: true,
+            screens: {
+              Baz: {
+                path: "baz"
               }
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles empty path at the end", function () {
-  var path = "/foo/bar",
-    config = {
-      screens: {
-        Foo: {
-          path: "foo",
-          screens: {
-            Bar: "bar"
-          }
-        },
-        Baz: {
-          path: ""
+  var path = "/foo/bar";
+  var config = {
+    screens: {
+      Foo: {
+        path: "foo",
+        screens: {
+          Bar: "bar"
         }
+      },
+      Baz: {
+        path: ""
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            state: {
-              routes: [{
-                name: "Baz"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "Baz"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test('returns "/" for empty path', function () {
-  var path = "/",
-    config = {
-      screens: {
-        Foo: {
-          path: "",
-          screens: {
-            Bar: ""
-          }
+  var path = "/";
+  var config = {
+    screens: {
+      Foo: {
+        path: "",
+        screens: {
+          Bar: ""
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar"
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar"
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("parses no path specified", function () {
-  var path = "/bar",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Foe: {},
-            Bar: "bar"
-          }
+  var path = "/bar";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Foe: {},
+          Bar: "bar"
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar"
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar"
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("strips undefined query params", function () {
-  var path = "/bar/sweet/apple/foo/bis/jane?count=10&valid=true",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              path: "foo",
-              screens: {
-                Foe: {
-                  path: "foe"
-                },
-                Baz: {
-                  screens: {
-                    Bos: "bos",
-                    Bis: {
-                      path: "bis/:author",
-                      stringify: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toLowerCase();
-                          });
-                        }
-                      },
-                      parse: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toUpperCase();
-                          });
-                        },
-                        count: Number,
-                        valid: Boolean
+  var path = "/bar/sweet/apple/foo/bis/jane?count=10&valid=true";
+  var config = {
+    screens: {
+      Bar: {
+        path: "bar/:type/:fruit",
+        screens: {
+          Foo: {
+            path: "foo",
+            screens: {
+              Foe: {
+                path: "foe"
+              },
+              Baz: {
+                screens: {
+                  Bos: "bos",
+                  Bis: {
+                    path: "bis/:author",
+                    stringify: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toLowerCase();
+                        });
                       }
+                    },
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
                     }
                   }
                 }
@@ -1047,73 +1069,74 @@ test("strips undefined query params", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple",
-          type: "sweet"
-        },
-        state: {
-          routes: [{
-            name: "Foo",
-            state: {
-              routes: [{
-                name: "Baz",
-                state: {
-                  routes: [{
-                    name: "Bis",
-                    params: {
-                      author: "Jane",
-                      count: 10,
-                      valid: !0
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple",
+        type: "sweet"
+      },
+      state: {
+        routes: [{
+          name: "Foo",
+          state: {
+            routes: [{
+              name: "Baz",
+              state: {
+                routes: [{
+                  name: "Bis",
+                  params: {
+                    author: "Jane",
+                    count: 10,
+                    valid: true
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("strips undefined query params with exact", function () {
-  var path = "/bis/jane?count=10&valid=true",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              path: "foo",
-              screens: {
-                Foe: {
-                  path: "foe"
-                },
-                Baz: {
-                  screens: {
-                    Bos: "bos",
-                    Bis: {
-                      path: "bis/:author",
-                      exact: !0,
-                      stringify: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toLowerCase();
-                          });
-                        }
-                      },
-                      parse: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toUpperCase();
-                          });
-                        },
-                        count: Number,
-                        valid: Boolean
+  var path = "/bis/jane?count=10&valid=true";
+  var config = {
+    screens: {
+      Bar: {
+        path: "bar/:type/:fruit",
+        screens: {
+          Foo: {
+            path: "foo",
+            screens: {
+              Foe: {
+                path: "foe"
+              },
+              Baz: {
+                screens: {
+                  Bos: "bos",
+                  Bis: {
+                    path: "bis/:author",
+                    exact: true,
+                    stringify: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toLowerCase();
+                        });
                       }
+                    },
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
                     }
                   }
                 }
@@ -1122,72 +1145,73 @@ test("strips undefined query params with exact", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple",
-          type: "sweet"
-        },
-        state: {
-          routes: [{
-            name: "Foo",
-            state: {
-              routes: [{
-                name: "Baz",
-                state: {
-                  routes: [{
-                    name: "Bis",
-                    params: {
-                      author: "Jane",
-                      count: 10,
-                      valid: !0
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple",
+        type: "sweet"
+      },
+      state: {
+        routes: [{
+          name: "Foo",
+          state: {
+            routes: [{
+              name: "Baz",
+              state: {
+                routes: [{
+                  name: "Bis",
+                  params: {
+                    author: "Jane",
+                    count: 10,
+                    valid: true
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles stripping all query params", function () {
-  var path = "/bar/sweet/apple/foo/bis/jane",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              path: "foo",
-              screens: {
-                Foe: {
-                  path: "foe"
-                },
-                Baz: {
-                  screens: {
-                    Bos: "bos",
-                    Bis: {
-                      path: "bis/:author",
-                      stringify: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toLowerCase();
-                          });
-                        }
-                      },
-                      parse: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toUpperCase();
-                          });
-                        },
-                        count: Number,
-                        valid: Boolean
+  var path = "/bar/sweet/apple/foo/bis/jane";
+  var config = {
+    screens: {
+      Bar: {
+        path: "bar/:type/:fruit",
+        screens: {
+          Foo: {
+            path: "foo",
+            screens: {
+              Foe: {
+                path: "foe"
+              },
+              Baz: {
+                screens: {
+                  Bos: "bos",
+                  Bis: {
+                    path: "bis/:author",
+                    stringify: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toLowerCase();
+                        });
                       }
+                    },
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
                     }
                   }
                 }
@@ -1196,72 +1220,73 @@ test("handles stripping all query params", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple",
-          type: "sweet"
-        },
-        state: {
-          routes: [{
-            name: "Foo",
-            state: {
-              routes: [{
-                name: "Baz",
-                state: {
-                  routes: [{
-                    name: "Bis",
-                    params: {
-                      author: "Jane"
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple",
+        type: "sweet"
+      },
+      state: {
+        routes: [{
+          name: "Foo",
+          state: {
+            routes: [{
+              name: "Baz",
+              state: {
+                routes: [{
+                  name: "Bis",
+                  params: {
+                    author: "Jane"
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("handles stripping all query params with exact", function () {
-  var path = "/bis/jane",
-    config = {
-      screens: {
-        Bar: {
-          path: "bar/:type/:fruit",
-          screens: {
-            Foo: {
-              path: "foo",
-              screens: {
-                Foe: {
-                  path: "foe"
-                },
-                Baz: {
-                  path: "baz",
-                  screens: {
-                    Bos: "bos",
-                    Bis: {
-                      path: "bis/:author",
-                      exact: !0,
-                      stringify: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toLowerCase();
-                          });
-                        }
-                      },
-                      parse: {
-                        author: function (author) {
-                          return author.replace(/^\w/, function (c) {
-                            return c.toUpperCase();
-                          });
-                        },
-                        count: Number,
-                        valid: Boolean
+  var path = "/bis/jane";
+  var config = {
+    screens: {
+      Bar: {
+        path: "bar/:type/:fruit",
+        screens: {
+          Foo: {
+            path: "foo",
+            screens: {
+              Foe: {
+                path: "foe"
+              },
+              Baz: {
+                path: "baz",
+                screens: {
+                  Bos: "bos",
+                  Bis: {
+                    path: "bis/:author",
+                    exact: true,
+                    stringify: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toLowerCase();
+                        });
                       }
+                    },
+                    parse: {
+                      author: function (author) {
+                        return author.replace(/^\w/, function (c) {
+                          return c.toUpperCase();
+                        });
+                      },
+                      count: Number,
+                      valid: Boolean
                     }
                   }
                 }
@@ -1270,239 +1295,248 @@ test("handles stripping all query params with exact", function () {
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple",
-          type: "sweet"
-        },
-        state: {
-          routes: [{
-            name: "Foo",
-            state: {
-              routes: [{
-                name: "Baz",
-                state: {
-                  routes: [{
-                    name: "Bis",
-                    params: {
-                      author: "Jane"
-                    }
-                  }]
-                }
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple",
+        type: "sweet"
+      },
+      state: {
+        routes: [{
+          name: "Foo",
+          state: {
+            routes: [{
+              name: "Baz",
+              state: {
+                routes: [{
+                  name: "Bis",
+                  params: {
+                    author: "Jane"
+                  }
+                }]
+              }
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 test("replaces undefined query params", function () {
-  var path = "/bar/undefined/apple",
-    config = {
-      screens: {
-        Bar: "bar/:type/:fruit"
-      }
-    },
-    state = {
-      routes: [{
-        name: "Bar",
-        params: {
-          fruit: "apple"
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+  var path = "/bar/undefined/apple";
+  var config = {
+    screens: {
+      Bar: "bar/:type/:fruit"
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Bar",
+      params: {
+        fruit: "apple"
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 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/"
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "404"
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe("/404"), expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/404");
+    }
+  };
+  var state = {
+    routes: [{
+      name: "404"
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe("/404");
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/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: "*"
-              }
+  var path = "/bar/42/whatever/baz/initt";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Bar: {
+            path: "/bar/:id/",
+            screens: {
+              404: "*"
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            params: {
-              id: "42"
-            },
-            state: {
-              routes: [{
-                name: "404"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe("/bar/42/404"), expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/bar/42/404");
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          params: {
+            id: "42"
+          },
+          state: {
+            routes: [{
+              name: "404"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe("/bar/42/404");
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/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
-                }
+  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",
-            state: {
-              routes: [{
-                name: "404"
-              }]
             }
-          }]
+          },
+          Baz: {}
         }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe("/404"), expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/404");
+      }
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          state: {
+            routes: [{
+              name: "404"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe("/404");
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/404");
 });
 test("tries to match wildcard patterns at the end", function () {
-  var path = "/bar/42/test",
-    config = {
-      screens: {
-        Foo: {
-          screens: {
-            Bar: {
-              path: "/bar/:id/",
-              screens: {
-                404: "*",
-                Test: "test"
-              }
+  var path = "/bar/42/test";
+  var config = {
+    screens: {
+      Foo: {
+        screens: {
+          Bar: {
+            path: "/bar/:id/",
+            screens: {
+              404: "*",
+              Test: "test"
             }
           }
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Bar",
-            params: {
-              id: "42"
-            },
-            state: {
-              routes: [{
-                name: "Test"
-              }]
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(path), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Bar",
+          params: {
+            id: "42"
+          },
+          state: {
+            routes: [{
+              name: "Test"
+            }]
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(path);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(path);
 });
 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"
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe("/404"), expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/404");
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "404"
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe("/404");
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe("/404");
 });
 test.skip("handles path at top level", function () {
-  var path = "foo/fruits/apple",
-    config = {
-      path: "foo",
-      screens: {
-        Foo: {
-          screens: {
-            Fruits: "fruits/:fruit"
-          }
+  var path = "foo/fruits/apple";
+  var config = {
+    path: "foo",
+    screens: {
+      Foo: {
+        screens: {
+          Fruits: "fruits/:fruit"
         }
       }
-    },
-    state = {
-      routes: [{
-        name: "Foo",
-        state: {
-          routes: [{
-            name: "Fruits",
-            params: {
-              fruit: "apple"
-            }
-          }]
-        }
-      }]
-    };
-  expect(getPathFromState(state, config)).toBe(`/${path}`), expect(getPathFromState(getStateFromPath(path, config), config)).toBe(`/${path}`);
+    }
+  };
+  var state = {
+    routes: [{
+      name: "Foo",
+      state: {
+        routes: [{
+          name: "Fruits",
+          params: {
+            fruit: "apple"
+          }
+        }]
+      }
+    }]
+  };
+  expect(getPathFromState(state, config)).toBe(`/${path}`);
+  expect(getPathFromState(getStateFromPath(path, config), config)).toBe(`/${path}`);
 });
 test.skip("ignores regexp patterns when provided", function () {
   var config = {
@@ -1536,14 +1570,16 @@ test.skip("ignores regexp patterns when provided", function () {
         id: 42
       }
     }]
-  }, config)).toBe("/foo/42"), expect(getPathFromState({
+  }, config)).toBe("/foo/42");
+  expect(getPathFromState({
     routes: [{
       name: "Bar",
       params: {
         id: "bar"
       }
     }]
-  }, config)).toBe("/foo/bar"), expect(getPathFromState({
+  }, config)).toBe("/foo/bar");
+  expect(getPathFromState({
     routes: [{
       name: "Baz",
       params: {
@@ -1551,7 +1587,8 @@ test.skip("ignores regexp patterns when provided", function () {
         name: "bar"
       }
     }]
-  }, config)).toBe("/foo/42/bar"), expect(getPathFromState({
+  }, config)).toBe("/foo/42/bar");
+  expect(getPathFromState({
     routes: [{
       name: "Qux",
       params: {