wj-elements 0.7.7 → 0.8.0

package/dist/wje-routerx.js

@@ -7,1445 +7,651 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _routes;
-import { r as routerLinks } from "./router-links-wjqCnncc.js";
-import WJElement from "./wje-element.js";
-const assoc = (obj, attr, val) => {
-  obj[attr] = val;
-  return obj;
-};
-const isArray = Array.isArray;
-const keys = Object.keys;
-const clone = (obj) => obj ? isArray(obj) ? obj.slice(0) : extend({}, obj) : obj;
-const pick = (obj, attrs) => attrs.reduce((acc, attr) => obj[attr] === void 0 ? acc : assoc(acc, attr, obj[attr]), {});
-const isEqual$1 = (obj1, obj2) => {
-  const keys1 = keys(obj1);
-  return keys1.length === keys(obj2).length && keys1.every((key) => obj2[key] === obj1[key]);
-};
-const extend = Object.assign;
-function invariant(condition, format, ...args) {
-  if (!condition) {
-    let argIndex = 0;
-    throw new Error("Invariant Violation: " + format.replace(/%s/g, () => args[argIndex++]));
-  }
-}
-function functionDsl(callback) {
-  let ancestors = [];
-  const matches = {};
-  const names = {};
-  callback(function route(name, options, childrenCallback) {
-    let routes;
-    invariant(
-      !names[name],
-      'Route names must be unique, but route "%s" is declared multiple times',
-      name
-    );
-    names[name] = true;
-    if (arguments.length === 1) {
-      options = {};
-    }
-    if (arguments.length === 2 && typeof options === "function") {
-      childrenCallback = options;
-      options = {};
-    }
-    if (typeof options.path !== "string") {
-      const parts = name.split(".");
-      options.path = parts[parts.length - 1];
-    }
-    if (childrenCallback) {
-      ancestors = ancestors.concat(name);
-      childrenCallback();
-      routes = pop();
-      ancestors.splice(-1);
-    }
-    push({
-      name,
-      path: options.path,
-      routes: routes || [],
-      options
-    });
-  });
-  function pop() {
-    return matches[currentLevel()] || [];
-  }
-  function push(route) {
-    const level = currentLevel();
-    matches[level] = matches[level] || [];
-    matches[level].push(route);
-  }
-  function currentLevel() {
-    return ancestors.join(".");
-  }
-  return pop();
-}
-function arrayDsl(routes) {
-  const result = [];
-  routes.forEach(({ name, children, ...options }) => {
-    if (typeof options.path !== "string") {
-      const parts = name.split(".");
-      options.path = parts[parts.length - 1];
-    }
-    result.push({
-      name,
-      path: options.path,
-      options,
-      routes: children ? arrayDsl(children) : []
-    });
-  });
-  return result;
-}
-const paramInjectMatcher = /:([a-zA-Z_$][a-zA-Z0-9_$?]*[?+*]?)/g;
-const specialParamChars = /[+*?]$/g;
-const queryMatcher = /\?(.+)/;
-const _compiledPatterns = {};
-function compilePattern(pattern, compiler) {
-  if (!(pattern in _compiledPatterns)) {
-    _compiledPatterns[pattern] = compiler(pattern);
-  }
-  return _compiledPatterns[pattern];
-}
-function extractParamNames(pattern, compiler) {
-  return compilePattern(pattern, compiler).paramNames;
-}
-function extractParams(pattern, path, compiler) {
-  const cp = compilePattern(pattern, compiler);
-  const matcher = cp.matcher;
-  const paramNames = cp.paramNames;
-  const match = path.match(matcher);
-  if (!match) {
-    return null;
-  }
-  const params = {};
-  paramNames.forEach(function(paramName, index) {
-    params[paramName] = match[index + 1] && decodeURIComponent(match[index + 1]);
-  });
-  return params;
-}
-function injectParams(pattern, params) {
-  params = params || {};
-  return pattern.replace(paramInjectMatcher, function(match, param) {
-    const paramName = param.replace(specialParamChars, "");
-    const lastChar = param.slice(-1);
-    if (lastChar === "?" || lastChar === "*") {
-      if (params[paramName] == null) {
-        return "";
-      }
-    } else {
-      invariant(
-        params[paramName] != null,
-        "Missing '%s' parameter for path '%s'",
-        paramName,
-        pattern
-      );
-    }
-    let paramValue = encodeURIComponent(params[paramName]);
-    if (lastChar === "*" || lastChar === "+") {
-      paramValue = paramValue.replace("%2F", "/");
-    }
-    return paramValue;
-  });
-}
-function extractQuery(qs2, path) {
-  const match = path.match(queryMatcher);
-  return match && qs2.parse(match[1]);
-}
-function withQuery(qs2, path, query) {
-  const queryString = qs2.stringify(query, { indices: false });
-  if (queryString) {
-    return withoutQuery(path) + "?" + queryString;
-  }
-  return path;
-}
-function withoutQuery(path) {
-  return path.replace(queryMatcher, "");
-}
-function bindEvent(el, type, fn) {
-  el.addEventListener(type, fn);
-  return fn;
-}
-function unbindEvent(el, type, fn) {
-  el.removeEventListener(type, fn);
-  return fn;
-}
-class History {
+var _t;
+import { r as t } from "./router-links-CNsJ-elb.js";
+import e from "./wje-element.js";
+const n = Array.isArray, r = Object.keys, o = (t2) => t2 ? n(t2) ? t2.slice(0) : i({}, t2) : t2, s = (t2, e2) => {
+  const n2 = r(t2);
+  return n2.length === r(e2).length && n2.every((n3) => e2[n3] === t2[n3]);
+}, i = Object.assign;
+function a(t2, e2, ...n2) {
+  if (!t2) {
+    let t3 = 0;
+    throw new Error("Invariant Violation: " + e2.replace(/%s/g, () => n2[t3++]));
+  }
+}
+function c(t2) {
+  let e2 = [];
+  const n2 = {}, r2 = {};
+  function o2() {
+    return n2[s2()] || [];
+  }
+  function s2() {
+    return e2.join(".");
+  }
+  return t2(function(t3, i2, c2) {
+    let h2;
+    if (a(!r2[t3], 'Route names must be unique, but route "%s" is declared multiple times', t3), r2[t3] = true, 1 === arguments.length && (i2 = {}), 2 === arguments.length && "function" == typeof i2 && (c2 = i2, i2 = {}), "string" != typeof i2.path) {
+      const e3 = t3.split(".");
+      i2.path = e3[e3.length - 1];
+    }
+    c2 && (e2 = e2.concat(t3), c2(), h2 = o2(), e2.splice(-1)), (function(t4) {
+      const e3 = s2();
+      n2[e3] = n2[e3] || [], n2[e3].push(t4);
+    })({ name: t3, path: i2.path, routes: h2 || [], options: i2 });
+  }), o2();
+}
+function h(t2) {
+  const e2 = [];
+  return t2.forEach(({ name: t3, children: n2, ...r2 }) => {
+    if ("string" != typeof r2.path) {
+      const e3 = t3.split(".");
+      r2.path = e3[e3.length - 1];
+    }
+    e2.push({ name: t3, path: r2.path, options: r2, routes: n2 ? h(n2) : [] });
+  }), e2;
+}
+const u = /:([a-zA-Z_$][a-zA-Z0-9_$?]*[?+*]?)/g, l = /[+*?]$/g, p = /\?(.+)/, f = {};
+function m(t2, e2) {
+  return t2 in f || (f[t2] = e2(t2)), f[t2];
+}
+function d(t2, e2) {
+  const n2 = e2.match(p);
+  return n2 && t2.parse(n2[1]);
+}
+function g(t2) {
+  return t2.replace(p, "");
+}
+function y(t2, e2, n2) {
+  return t2.addEventListener(e2, n2), n2;
+}
+function w(t2, e2, n2) {
+  return t2.removeEventListener(e2, n2), n2;
+}
+class b {
   constructor() {
-    this.handlers = [];
-    this.checkUrl = this.checkUrl.bind(this);
-    this.location = window.location;
-    this.history = window.history;
+    this.handlers = [], this.checkUrl = this.checkUrl.bind(this), this.location = window.location, this.history = window.history;
   }
-  // Set up all inheritable **Backbone.History** properties and methods.
-  // Are we at the app root?
   atRoot() {
     return this.location.pathname.replace(/[^\/]$/, "$&/") === this.root;
   }
-  // Gets the true hash value. Cannot use location.hash directly due to bug
-  // in Firefox where location.hash will always be decoded.
   getHash() {
-    const match = this.location.href.match(/#(.*)$/);
-    return match ? match[1] : "";
-  }
-  // Get the cross-browser normalized URL fragment, either from the URL,
-  // the hash, or the override.
-  getFragment(fragment, forcePushState) {
-    if (fragment == null) {
-      if (this._hasPushState || !this._wantsHashChange || forcePushState) {
-        fragment = decodeURI(this.location.pathname + this.location.search);
-        const root = this.root.replace(trailingSlash, "");
-        if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
-      } else {
-        fragment = this.getHash();
-      }
-    }
-    return fragment.replace(routeStripper, "");
-  }
-  // Start the hash change handling, returning `true` if the current URL matches
-  // an existing route, and `false` otherwise.
-  start(options) {
+    const t2 = this.location.href.match(/#(.*)$/);
+    return t2 ? t2[1] : "";
+  }
+  getFragment(t2, e2) {
+    if (null == t2) if (this._hasPushState || !this._wantsHashChange || e2) {
+      t2 = decodeURI(this.location.pathname + this.location.search);
+      const e3 = this.root.replace(R, "");
+      t2.indexOf(e3) || (t2 = t2.slice(e3.length));
+    } else t2 = this.getHash();
+    return t2.replace(v, "");
+  }
+  start(t2) {
     this.started = true;
-    const _wantsPushState = !!options.pushState;
-    this.location = options.location || this.location;
-    this.history = options.history || this.history;
-    this.root = options.root;
-    this._wantsHashChange = options.hashChange !== false;
-    this._hasPushState = _wantsPushState;
-    const fragment = this.getFragment();
-    this.root = `/${this.root}/`.replace(rootStripper, "/");
-    bindEvent(window, this._hasPushState ? "popstate" : "hashchange", this.checkUrl);
-    this.fragment = fragment;
-    const loc = this.location;
-    if (this._wantsHashChange && _wantsPushState) {
-      if (!this._hasPushState && !this.atRoot()) {
-        this.fragment = this.getFragment(null, true);
-        this.location.replace(`${this.root}#${this.fragment}`);
-        return true;
-      } else if (this._hasPushState && this.atRoot() && loc.hash) {
-        this.fragment = this.getHash().replace(routeStripper, "");
-        this.history.replaceState({}, document.title, this.root + this.fragment);
-      }
+    const e2 = !!t2.pushState;
+    this.location = t2.location || this.location, this.history = t2.history || this.history, this.root = t2.root, this._wantsHashChange = false !== t2.hashChange, this._hasPushState = e2;
+    const n2 = this.getFragment();
+    this.root = `/${this.root}/`.replace(E, "/"), y(window, this._hasPushState ? "popstate" : "hashchange", this.checkUrl), this.fragment = n2;
+    const r2 = this.location;
+    if (this._wantsHashChange && e2) {
+      if (!this._hasPushState && !this.atRoot()) return this.fragment = this.getFragment(null, true), this.location.replace(`${this.root}#${this.fragment}`), true;
+      this._hasPushState && this.atRoot() && r2.hash && (this.fragment = this.getHash().replace(v, ""), this.history.replaceState({}, document.title, this.root + this.fragment));
     }
-    if (!options.silent) return this.loadUrl();
+    if (!t2.silent) return this.loadUrl();
   }
-  // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
-  // but possibly useful for unit testing Routers.
   stop() {
-    unbindEvent(window, this._hasPushState ? "popstate" : "hashchange", this.checkUrl);
-    this.started = false;
+    w(window, this._hasPushState ? "popstate" : "hashchange", this.checkUrl), this.started = false;
   }
-  // Add a route to be tested when the fragment changes. Routes added later
-  // may override previous routes.
-  route(route, callback) {
-    this.handlers.unshift({ route, callback });
+  route(t2, e2) {
+    this.handlers.unshift({ route: t2, callback: e2 });
   }
-  // Checks the current URL to see if it has changed, and if it has,
-  // calls `loadUrl`.
   checkUrl() {
-    const current = this.getFragment();
-    if (current === this.fragment) return false;
+    if (this.getFragment() === this.fragment) return false;
     this.loadUrl();
   }
-  // Attempt to load the current URL fragment. If a route succeeds with a
-  // match, returns `true`. If no defined routes matches the fragment,
-  // returns `false`.
-  loadUrl(fragment) {
-    fragment = this.fragment = this.getFragment(fragment);
-    return this.handlers.some((handler) => {
-      if (handler.route.test(fragment)) {
-        handler.callback(fragment);
-        return true;
-      }
+  loadUrl(t2) {
+    return t2 = this.fragment = this.getFragment(t2), this.handlers.some((e2) => {
+      if (e2.route.test(t2)) return e2.callback(t2), true;
     });
   }
-  // Save a fragment into the hash history, or replace the URL state if the
-  // 'replace' option is passed. You are responsible for properly URL-encoding
-  // the fragment in advance.
-  //
-  // The options object can contain `trigger: true` if you wish to have the
-  // route callback be fired (not usually desirable), or `replace: true`, if
-  // you wish to modify the current URL without adding an entry to the history.
-  update(fragment, options) {
+  update(t2, e2) {
     if (!this.started) return false;
-    if (!options || options === true) options = { trigger: !!options };
-    let url = this.root + (fragment = this.getFragment(fragment || ""));
-    fragment = fragment.replace(pathStripper, "");
-    if (this.fragment === fragment) return;
-    this.fragment = fragment;
-    if (fragment === "" && url !== "/") url = url.slice(0, -1);
-    if (this._hasPushState) {
-      this.history[options.replace ? "replaceState" : "pushState"]({}, document.title, url);
-    } else if (this._wantsHashChange) {
-      this._updateHash(this.location, fragment, options.replace);
-    } else {
-      return this.location.assign(url);
-    }
-    if (options.trigger) return this.loadUrl(fragment);
-  }
-  // Update the hash location, either replacing the current entry, or adding
-  // a new one to the browser history.
-  _updateHash(location, fragment, replace) {
-    if (replace) {
-      const href = location.href.replace(/(javascript:|#).*$/, "");
-      location.replace(`${href}#${fragment}`);
-    } else {
-      location.hash = `#${fragment}`;
+    e2 && true !== e2 || (e2 = { trigger: !!e2 });
+    let n2 = this.root + (t2 = this.getFragment(t2 || ""));
+    if (t2 = t2.replace($, ""), this.fragment !== t2) {
+      if (this.fragment = t2, "" === t2 && "/" !== n2 && (n2 = n2.slice(0, -1)), this._hasPushState) this.history[e2.replace ? "replaceState" : "pushState"]({}, document.title, n2);
+      else {
+        if (!this._wantsHashChange) return this.location.assign(n2);
+        this._updateHash(this.location, t2, e2.replace);
+      }
+      return e2.trigger ? this.loadUrl(t2) : void 0;
     }
   }
-  // add some features to History
-  // a generic callback for any changes
-  onChange(callback) {
-    this.route(/^(.*?)$/, callback);
+  _updateHash(t2, e2, n2) {
+    if (n2) {
+      const n3 = t2.href.replace(/(javascript:|#).*$/, "");
+      t2.replace(`${n3}#${e2}`);
+    } else t2.hash = `#${e2}`;
+  }
+  onChange(t2) {
+    this.route(/^(.*?)$/, t2);
   }
 }
-const routeStripper = /^[#\/]|\s+$/g;
-const rootStripper = /^\/+|\/+$/g;
-const trailingSlash = /\/$/;
-const pathStripper = /#.*$/;
-class BrowserLocation {
-  /**
-   * @param {BrowserLocationOptions} options
-   */
-  constructor(options = {}) {
-    this.path = options.path || "";
-    this.options = extend(
-      {
-        pushState: false,
-        root: "/"
-      },
-      options
-    );
-    this.history = new History();
-  }
-  /**
-   * Get the current URL
-   */
+const v = /^[#\/]|\s+$/g, E = /^\/+|\/+$/g, R = /\/$/, $ = /#.*$/;
+class T {
+  constructor(t2 = {}) {
+    this.path = t2.path || "", this.options = i({ pushState: false, root: "/" }, t2), this.history = new b();
+  }
   getURL() {
     return this.path;
   }
-  /**
-   * Set the current URL without triggering any events
-   * back to the router. Add a new entry in browser's history.
-   */
-  setURL(path, options = {}) {
-    if (this.path !== path) {
-      this.path = path;
-      this.history.update(path, extend({ trigger: true }, options));
-    }
+  setURL(t2, e2 = {}) {
+    this.path !== t2 && (this.path = t2, this.history.update(t2, i({ trigger: true }, e2)));
   }
-  /**
-   * Set the current URL without triggering any events
-   * back to the router. Replace the latest entry in broser's history.
-   */
-  replaceURL(path, options = {}) {
-    if (this.path !== path) {
-      this.path = path;
-      this.history.update(path, extend({ trigger: true, replace: true }, options));
-    }
+  replaceURL(t2, e2 = {}) {
+    this.path !== t2 && (this.path = t2, this.history.update(t2, i({ trigger: true, replace: true }, e2)));
   }
-  /**
-   * Setup a URL change handler
-   * @param  {(url: string) => void} callback
-   */
-  onChange(callback) {
-    this.callback = callback;
-  }
-  /**
-   * Given a path, generate a URL appending root
-   * if pushState is used and # if hash state is used
-   */
-  formatURL(path) {
-    const { root, pushState } = this.options;
-    if (pushState) {
-      let rootURL = root;
-      if (path !== "") {
-        rootURL = rootURL.replace(/\/$/, "");
-      }
-      return rootURL + path;
-    } else {
-      if (path[0] === "/") {
-        path = path.substr(1);
-      }
-      return `#${path}`;
-    }
+  onChange(t2) {
+    this.callback = t2;
   }
-  /**
-   * When we use pushState with a custom root option,
-   * we need to take care of removingRoot at certain points.
-   * Specifically
-   * - browserLocation.update() can be called with the full URL by router
-   * - LocationBar expects all .update() calls to be called without root
-   * - this method is public so that we could dispatch URLs without root in router
-   */
-  removeRoot(url) {
-    const { root, pushState } = this.options;
-    if (pushState && root && root !== "/") {
-      return url.replace(root, "");
-    } else {
-      return url;
+  formatURL(t2) {
+    const { root: e2, pushState: n2 } = this.options;
+    if (n2) {
+      let n3 = e2;
+      return "" !== t2 && (n3 = n3.replace(/\/$/, "")), n3 + t2;
     }
+    return "/" === t2[0] && (t2 = t2.substr(1)), `#${t2}`;
+  }
+  removeRoot(t2) {
+    const { root: e2, pushState: n2 } = this.options;
+    return n2 && e2 && "/" !== e2 ? t2.replace(e2, "") : t2;
   }
-  /**
-   * Stop listening to URL changes and link clicks
-   */
   destroy() {
     this.history.stop();
   }
-  /**
-      initially, the changeCallback won't be defined yet, but that's good
-      because we dont' want to kick off routing right away, the router
-      does that later by manually calling this handleURL method with the
-      url it reads of the location. But it's important this is called
-      first by Backbone, because we wanna set a correct this.path value
-  
-      @private
-     */
-  handleURL(url) {
-    this.path = url;
-    if (this.callback) {
-      this.callback(url);
-    }
+  handleURL(t2) {
+    this.path = t2, this.callback && this.callback(t2);
   }
-  start(path) {
-    this.path = path;
-    this.history.onChange((path2) => {
-      this.handleURL(`/${path2 || ""}`);
-    });
-    this.history.start(this.options);
+  start(t2) {
+    this.path = t2, this.history.onChange((t3) => {
+      this.handleURL(`/${t3 || ""}`);
+    }), this.history.start(this.options);
   }
 }
-class MemoryLocation {
+class U {
   constructor() {
     this.path = "";
   }
   getURL() {
     return this.path;
   }
-  setURL(path, options) {
-    if (this.path !== path) {
-      this.path = path;
-      this.handleURL(this.getURL(), options);
-    }
+  setURL(t2, e2) {
+    this.path !== t2 && (this.path = t2, this.handleURL(this.getURL(), e2));
   }
-  replaceURL(path, options) {
-    if (this.path !== path) {
-      this.setURL(path, options);
-    }
+  replaceURL(t2, e2) {
+    this.path !== t2 && this.setURL(t2, e2);
   }
-  onChange(callback) {
-    this.callback = callback;
+  onChange(t2) {
+    this.callback = t2;
   }
-  handleURL(url, options) {
-    this.path = url;
-    const shouldTrigger = (options == null ? void 0 : options.trigger) !== false;
-    if (this.callback && shouldTrigger) {
-      this.callback(url);
-    }
+  handleURL(t2, e2) {
+    this.path = t2;
+    const n2 = false !== (e2 == null ? void 0 : e2.trigger);
+    this.callback && n2 && this.callback(t2);
   }
-  removeRoot(url) {
-    return url;
+  removeRoot(t2) {
+    return t2;
   }
-  formatURL(url) {
-    return url;
+  formatURL(t2) {
+    return t2;
   }
-  start(path) {
-    this.path = path;
+  start(t2) {
+    this.path = t2;
   }
 }
-const TRANSITION_REDIRECTED = "TransitionRedirected";
-const TRANSITION_CANCELLED = "TransitionCancelled";
-function runError(router2, transition2, err) {
-  router2.middleware.forEach((m) => {
-    m.error && m.error(transition2, err);
+const k = "TransitionRedirected", L = "TransitionCancelled";
+function C(t2, e2, n2) {
+  t2.middleware.forEach((t3) => {
+    t3.error && t3.error(e2, n2);
   });
 }
-function transition(options) {
-  options = options || {};
-  const router2 = options.router;
-  const log = router2.log;
-  const logError = router2.logError;
-  const path = options.path;
-  const match = options.match;
-  const routes = match.routes;
-  const params = match.params;
-  const pathname = match.pathname;
-  const query = match.query;
-  const id = options.id;
-  const startTime = Date.now();
-  log("---");
-  log("Transition #" + id, "to", path);
-  log(
-    "Transition #" + id,
-    "routes:",
-    routes.map((r) => r.name)
-  );
-  log("Transition #" + id, "params:", params);
-  log("Transition #" + id, "query:", query);
-  let resolve2, reject;
-  const promise = new Promise(function(res, rej) {
-    resolve2 = res;
-    reject = rej;
+function j(t2) {
+  const e2 = (t2 = t2 || {}).router, n2 = e2.log, r2 = e2.logError, s2 = t2.path, i2 = t2.match, c2 = i2.routes, h2 = i2.params, u2 = i2.pathname, l2 = i2.query, p2 = t2.id, f2 = Date.now();
+  let m2, d2;
+  n2("---"), n2("Transition #" + p2, "to", s2), n2("Transition #" + p2, "routes:", c2.map((t3) => t3.name)), n2("Transition #" + p2, "params:", h2), n2("Transition #" + p2, "query:", l2);
+  const g2 = new Promise(function(t3, e3) {
+    m2 = t3, d2 = e3;
   });
-  promise.then(function() {
-    log("Transition #" + id, "completed in", Date.now() - startTime + "ms");
-  }).catch(function(err) {
-    if (err.type !== TRANSITION_REDIRECTED && err.type !== TRANSITION_CANCELLED) {
-      log("Transition #" + id, "FAILED");
-      logError(err);
-    }
+  g2.then(function() {
+    n2("Transition #" + p2, "completed in", Date.now() - f2 + "ms");
+  }).catch(function(t3) {
+    t3.type !== k && t3.type !== L && (n2("Transition #" + p2, "FAILED"), r2(t3));
   });
-  let cancelled = false;
-  const transition2 = {
-    id,
-    prev: {
-      routes: clone(router2.state.routes) || [],
-      path: router2.state.path || "",
-      pathname: router2.state.pathname || "",
-      params: clone(router2.state.params) || {},
-      query: clone(router2.state.query) || {}
-    },
-    routes: clone(routes),
-    path,
-    pathname,
-    params: clone(params),
-    query: clone(query),
-    redirectTo: function(...args) {
-      return router2.transitionTo(...args);
-    },
-    retry: function() {
-      return router2.transitionTo(path);
-    },
-    cancel: function(err) {
-      if (router2.state.activeTransition !== transition2) {
-        return;
-      }
-      if (transition2.isCancelled) {
-        return;
-      }
-      router2.state.activeTransition = null;
-      transition2.isCancelled = true;
-      cancelled = true;
-      if (!err) {
-        err = new Error(TRANSITION_CANCELLED);
-        err.type = TRANSITION_CANCELLED;
-      }
-      if (err.type === TRANSITION_CANCELLED) {
-        log("Transition #" + id, "cancelled");
-      }
-      if (err.type === TRANSITION_REDIRECTED) {
-        log("Transition #" + id, "redirected");
-      }
-      router2.middleware.forEach((m) => {
-        m.cancel && m.cancel(transition2, err);
-      });
-      reject(err);
-    },
-    followRedirects: function() {
-      return promise.catch(function(reason) {
-        if (router2.state.activeTransition) {
-          return router2.state.activeTransition.followRedirects();
-        }
-        return Promise.reject(reason);
-      });
-    },
-    then: promise.then.bind(promise),
-    catch: promise.catch.bind(promise)
-  };
-  router2.middleware.forEach((m) => {
-    m.before && m.before(transition2);
-  });
-  function callNext(i, prevResult) {
-    let middleware;
-    let middlewareName;
-    if (cancelled) {
-      return;
-    }
-    if (i < router2.middleware.length) {
-      middleware = router2.middleware[i];
-      middlewareName = middleware.name || "anonymous";
-      log("Transition #" + id, "resolving middleware:", middlewareName);
-      let middlewarePromise;
+  let y2 = false;
+  const w2 = { id: p2, prev: { routes: o(e2.state.routes) || [], path: e2.state.path || "", pathname: e2.state.pathname || "", params: o(e2.state.params) || {}, query: o(e2.state.query) || {} }, routes: o(c2), path: s2, pathname: u2, params: o(h2), query: o(l2), redirectTo: function(...t3) {
+    return e2.transitionTo(...t3);
+  }, retry: function() {
+    return e2.transitionTo(s2);
+  }, cancel: function(t3) {
+    e2.state.activeTransition === w2 && (w2.isCancelled || (e2.state.activeTransition = null, w2.isCancelled = true, y2 = true, t3 || ((t3 = new Error(L)).type = L), t3.type === L && n2("Transition #" + p2, "cancelled"), t3.type === k && n2("Transition #" + p2, "redirected"), e2.middleware.forEach((e3) => {
+      e3.cancel && e3.cancel(w2, t3);
+    }), d2(t3)));
+  }, followRedirects: function() {
+    return g2.catch(function(t3) {
+      return e2.state.activeTransition ? e2.state.activeTransition.followRedirects() : Promise.reject(t3);
+    });
+  }, then: g2.then.bind(g2), catch: g2.catch.bind(g2) };
+  function b2(t3, r3) {
+    let o2, i3;
+    if (!y2) if (t3 < e2.middleware.length) {
+      let s3;
+      o2 = e2.middleware[t3], i3 = o2.name || "anonymous", n2("Transition #" + p2, "resolving middleware:", i3);
       try {
-        middlewarePromise = middleware.resolve ? middleware.resolve(transition2, prevResult) : prevResult;
-        invariant(
-          transition2 !== middlewarePromise,
-          "Middleware %s returned a transition which resulted in a deadlock",
-          middlewareName
-        );
-      } catch (err) {
-        router2.state.activeTransition = null;
-        runError(router2, transition2, err);
-        return reject(err);
+        s3 = o2.resolve ? o2.resolve(w2, r3) : r3, a(w2 !== s3, "Middleware %s returned a transition which resulted in a deadlock", i3);
+      } catch (t4) {
+        return e2.state.activeTransition = null, C(e2, w2, t4), d2(t4);
       }
-      Promise.resolve(middlewarePromise).then(function(result) {
-        callNext(i + 1, result);
-      }).catch(function(err) {
-        log("Transition #" + id, "resolving middleware:", middlewareName, "FAILED");
-        router2.state.activeTransition = null;
-        runError(router2, transition2, err);
-        reject(err);
-      });
-    } else {
-      router2.state = {
-        activeTransition: null,
-        routes,
-        path,
-        pathname,
-        params,
-        query
-      };
-      router2.middleware.forEach((m) => {
-        m.done && m.done(transition2);
+      Promise.resolve(s3).then(function(e3) {
+        b2(t3 + 1, e3);
+      }).catch(function(t4) {
+        n2("Transition #" + p2, "resolving middleware:", i3, "FAILED"), e2.state.activeTransition = null, C(e2, w2, t4), d2(t4);
       });
-      resolve2();
-    }
-  }
-  if (!options.noop) {
-    Promise.resolve().then(() => callNext(0));
-  } else {
-    resolve2();
-  }
-  if (options.noop) {
-    transition2.noop = true;
-  }
-  return transition2;
-}
-function intercept(el, fn) {
-  const cb = delegate(el, "click", function(e, el2) {
-    if (clickable(e, el2)) fn(e, el2);
+    } else e2.state = { activeTransition: null, routes: c2, path: s2, pathname: u2, params: h2, query: l2 }, e2.middleware.forEach((t4) => {
+      t4.done && t4.done(w2);
+    }), m2();
+  }
+  return e2.middleware.forEach((t3) => {
+    t3.before && t3.before(w2);
+  }), t2.noop ? m2() : Promise.resolve().then(() => b2(0)), t2.noop && (w2.noop = true), w2;
+}
+function S(t2, e2) {
+  const n2 = (function(t3, e3, n3) {
+    return y(t3, e3, function(t4) {
+      const e4 = t4.target.closest("a");
+      e4 && n3(t4, e4);
+    });
+  })(t2, "click", function(t3, n3) {
+    (function(t4, e3) {
+      if (1 !== (function(t5) {
+        return t5 = t5 || window.event, null === t5.which ? t5.button : t5.which;
+      })(t4)) return;
+      if (t4.metaKey || t4.ctrlKey || t4.shiftKey) return;
+      if (t4.defaultPrevented) return;
+      if (e3.target) return;
+      if (null !== e3.getAttribute("data-bypass")) return;
+      const n4 = e3.getAttribute("href");
+      if (!n4 || 0 === n4.length) return;
+      if (/^(#|https{0,1}:\/\/|mailto|javascript:)/i.test(n4)) return;
+      return true;
+    })(t3, n3) && e2(t3, n3);
   });
-  return function dispose() {
-    unbindEvent(el, "click", cb);
+  return function() {
+    w(t2, "click", n2);
   };
 }
-function delegate(el, type, fn) {
-  return bindEvent(el, type, function(e) {
-    const el2 = e.target.closest("a");
-    if (el2) {
-      fn(e, el2);
-    }
+function O(t2, e2, n2) {
+  true !== n2 && (t2[e2] = "function" == typeof n2 ? n2 : () => {
   });
 }
-function clickable(e, el) {
-  if (which(e) !== 1) return;
-  if (e.metaKey || e.ctrlKey || e.shiftKey) return;
-  if (e.defaultPrevented) return;
-  if (el.target) return;
-  if (el.getAttribute("data-bypass") !== null) return;
-  const href = el.getAttribute("href");
-  if (!href || href.length === 0) return;
-  if (/^(#|https{0,1}:\/\/|mailto|javascript:)/i.test(href)) return;
-  return true;
-}
-function which(e) {
-  e = e || window.event;
-  return e.which === null ? e.button : e.which;
-}
-function defineLogger(router2, method, fn) {
-  if (fn === true) return;
-  router2[method] = typeof fn === "function" ? fn : () => {
-  };
-}
-const qs = {
-  parse(querystring) {
-    return querystring.split("&").reduce((acc, pair) => {
-      const parts = pair.split("=");
-      acc[parts[0]] = decodeURIComponent(parts[1]);
-      return acc;
-    }, {});
-  },
-  stringify(params) {
-    return Object.keys(params).reduce((acc, key) => {
-      if (params[key] !== void 0) {
-        acc.push(key + "=" + encodeURIComponent(params[key]));
-      }
-      return acc;
-    }, []).join("&");
-  }
-};
-function parse(input, loose) {
-  if (input instanceof RegExp) return { keys: false, pattern: input };
-  var c, o, tmp, ext, keys2 = [], pattern = "", arr = input.split("/");
-  arr[0] || arr.shift();
-  while (tmp = arr.shift()) {
-    c = tmp[0];
-    if (c === "*") {
-      keys2.push(c);
-      pattern += tmp[1] === "?" ? "(?:/(.*))?" : "/(.*)";
-    } else if (c === ":") {
-      o = tmp.indexOf("?", 1);
-      ext = tmp.indexOf(".", 1);
-      keys2.push(tmp.substring(1, !!~o ? o : !!~ext ? ext : tmp.length));
-      pattern += !!~o && !~ext ? "(?:/([^/]+?))?" : "/([^/]+?)";
-      if (!!~ext) pattern += (!!~o ? "?" : "") + "\\" + tmp.substring(ext);
-    } else {
-      pattern += "/" + tmp;
-    }
-  }
-  return {
-    keys: keys2,
-    pattern: new RegExp("^" + pattern + "/?$", "i")
-  };
-}
-const splatRegex = /:(\w+)\*/;
-function patternCompiler(pattern) {
-  const splatMatch = splatRegex.exec(pattern);
-  const normalizedPattern = splatMatch ? pattern.replace(splatRegex, "*") : pattern;
-  const { pattern: matcher, keys: keys2 } = parse(normalizedPattern);
-  const paramNames = splatMatch ? keys2.map((key) => key === "*" ? splatMatch[1] : key) : keys2;
-  return {
-    matcher,
-    paramNames
-  };
-}
-function createLocation(options) {
-  const location = options.location;
-  if (typeof location !== "string") {
-    return location;
-  }
-  if (location === "browser") {
-    const { pushState, root } = options;
-    return new BrowserLocation({ pushState, root });
-  } else if (location === "memory") {
-    return new MemoryLocation();
-  } else {
-    throw new Error("Location can be `browser`, `memory` or a custom implementation");
-  }
-}
-let Router$1 = class Router {
-  /**
-   * @param {RouterOptions} [options]
-   */
-  constructor(options = {}) {
-    this.nextId = 1;
-    this.state = {};
-    this.middleware = [];
-    this.options = extend(
-      {
-        location: "browser",
-        logError: true,
-        qs,
-        patternCompiler
-      },
-      options
-    );
-    defineLogger(this, "log", this.options.log);
-    defineLogger(this, "logError", this.options.logError);
-    if (options.routes) {
-      this.map(options.routes);
-    }
-    this.location = createLocation(this.options);
-  }
-  /**
-   * Add a middleware
-   * @param  {((transition: Transition) => void) | RouterMiddleware} middleware
-   * @param  {object} [options]
-   * @param  {number} [options.at] position to insert the middleware
-   * @return {Router}
-   * @api public
-   */
-  use(middleware, options = {}) {
-    const m = typeof middleware === "function" ? { resolve: middleware } : middleware;
-    typeof options.at === "number" ? this.middleware.splice(options.at, 0, m) : this.middleware.push(m);
-    m.create && m.create(this);
-    return this;
-  }
-  /**
-   * Add the route map
-   * @param  {routeCallback | RouteDef[]} routes
-   * @return {Router}
-   * @api public
-   */
-  map(routes) {
-    this.routes = Array.isArray(routes) ? arrayDsl(routes) : functionDsl(routes);
-    const matchers = this.matchers = [];
-    const dupes = {};
-    const abstracts = {};
-    eachBranch({ routes: this.routes }, [], (routes2) => {
-      let path = routes2.reduce(
-        (memo, r) => (
-          // and keep resetting the trailing slash
-          (r.path[0] === "/" ? r.path : `${memo}/${r.path}`).replace(/\/$/, "")
-        ),
-        ""
-      );
-      if (path === "") {
-        path = "/";
-      }
-      const lastRoute = routes2[routes2.length - 1];
-      if (lastRoute.options.abstract) {
-        abstracts[path] = lastRoute.name;
-        return;
-      }
-      if (lastRoute.path === "") {
-        let matcher;
-        matchers.some((m) => {
-          if (m.path === path) {
-            matcher = m;
-            return true;
-          }
-        });
-        if (matcher) {
-          matcher.routes = routes2;
-        } else if (abstracts[path]) {
-          matchers.push({
-            routes: routes2,
-            name: abstracts[path],
-            path
-          });
-        }
-      }
-      matchers.push({
-        routes: routes2,
-        name: lastRoute.name,
-        path
-      });
-      if (dupes[path] && lastRoute.path !== "") {
-        throw new Error(
-          `Routes ${dupes[path]} and ${lastRoute.name} have the same url path '${path}'`
-        );
+const q = { parse: (t2) => t2.split("&").reduce((t3, e2) => {
+  const n2 = e2.split("=");
+  return t3[n2[0]] = decodeURIComponent(n2[1]), t3;
+}, {}), stringify: (t2) => Object.keys(t2).reduce((e2, n2) => (void 0 !== t2[n2] && e2.push(n2 + "=" + encodeURIComponent(t2[n2])), e2), []).join("&") };
+const x = /:(\w+)\*/;
+function P(t2) {
+  const e2 = x.exec(t2), n2 = e2 ? t2.replace(x, "*") : t2, { pattern: r2, keys: o2 } = (function(t3) {
+    if (t3 instanceof RegExp) return { keys: false, pattern: t3 };
+    var e3, n3, r3, o3, s2 = [], i2 = "", a2 = t3.split("/");
+    for (a2[0] || a2.shift(); r3 = a2.shift(); ) "*" === (e3 = r3[0]) ? (s2.push(e3), i2 += "?" === r3[1] ? "(?:/(.*))?" : "/(.*)") : ":" === e3 ? (n3 = r3.indexOf("?", 1), o3 = r3.indexOf(".", 1), s2.push(r3.substring(1, ~n3 ? n3 : ~o3 ? o3 : r3.length)), i2 += ~n3 && !~o3 ? "(?:/([^/]+?))?" : "/([^/]+?)", ~o3 && (i2 += (~n3 ? "?" : "") + "\\" + r3.substring(o3))) : i2 += "/" + r3;
+    return { keys: s2, pattern: new RegExp("^" + i2 + "/?$", "i") };
+  })(n2);
+  return { matcher: r2, paramNames: e2 ? o2.map((t3) => "*" === t3 ? e2[1] : t3) : o2 };
+}
+let A = class {
+  constructor(t2 = {}) {
+    this.nextId = 1, this.state = {}, this.middleware = [], this.options = i({ location: "browser", logError: true, qs: q, patternCompiler: P }, t2), O(this, "log", this.options.log), O(this, "logError", this.options.logError), t2.routes && this.map(t2.routes), this.location = (function(t3) {
+      const e2 = t3.location;
+      if ("string" != typeof e2) return e2;
+      if ("browser" === e2) {
+        const { pushState: e3, root: n2 } = t3;
+        return new T({ pushState: e3, root: n2 });
       }
-      dupes[path] = lastRoute.name;
-    });
-    function eachBranch(node, memo, fn) {
-      node.routes.forEach((route) => {
-        fn(memo.concat(route));
-        if (route.routes.length) {
-          eachBranch(route, memo.concat(route), fn);
-        }
+      if ("memory" === e2) return new U();
+      throw new Error("Location can be `browser`, `memory` or a custom implementation");
+    })(this.options);
+  }
+  use(t2, e2 = {}) {
+    const n2 = "function" == typeof t2 ? { resolve: t2 } : t2;
+    return "number" == typeof e2.at ? this.middleware.splice(e2.at, 0, n2) : this.middleware.push(n2), n2.create && n2.create(this), this;
+  }
+  map(t2) {
+    this.routes = Array.isArray(t2) ? h(t2) : c(t2);
+    const e2 = this.matchers = [], n2 = {}, r2 = {};
+    return (function t3(e3, n3, r3) {
+      e3.routes.forEach((e4) => {
+        r3(n3.concat(e4)), e4.routes.length && t3(e4, n3.concat(e4), r3);
       });
-    }
-    return this;
-  }
-  /**
-   * Starts listening to the location changes.
-   * @param  {String}  [path]
-   * @return {Transition} initial transition
-   *
-   * @api public
-   */
-  listen(path) {
-    const location = this.location;
-    location.start(path);
-    location.onChange((url) => {
-      const previousUrl = this.state.path;
-      this.dispatch(url).catch((err) => {
-        if (err && err.type === TRANSITION_CANCELLED) {
-          this.location.replaceURL(previousUrl, { trigger: false });
+    })({ routes: this.routes }, [], (t3) => {
+      let o2 = t3.reduce((t4, e3) => ("/" === e3.path[0] ? e3.path : `${t4}/${e3.path}`).replace(/\/$/, ""), "");
+      "" === o2 && (o2 = "/");
+      const s2 = t3[t3.length - 1];
+      if (s2.options.abstract) r2[o2] = s2.name;
+      else {
+        if ("" === s2.path) {
+          let n3;
+          e2.some((t4) => {
+            if (t4.path === o2) return n3 = t4, true;
+          }), n3 ? n3.routes = t3 : r2[o2] && e2.push({ routes: t3, name: r2[o2], path: o2 });
         }
-        return err;
-      });
-    });
-    return this.dispatch(location.getURL());
-  }
-  /**
-   * Transition to a different route. Passe in url or a route name followed by params and query
-   * @param  {String} name     url or route name
-   * @param  {Object} [params]  Optional
-   * @param  {Object} [query]   Optional
-   * @return {Transition}         transition
-   *
-   * @api public
-   */
-  transitionTo(name, params, query) {
-    if (this.state.activeTransition) {
-      return this.replaceWith(name, params, query);
-    }
-    return this.doTransition("setURL", name, params, query);
-  }
-  /**
-   * Like transitionTo, but doesn't leave an entry in the browser's history,
-   * so clicking back will skip this route
-   * @param  {String} name     url or route name followed by params and query
-   * @param  {Record<string, any>} [params]
-   * @param  {Record<string, any>} [query]
-   * @return {Transition}         transition
-   *
-   * @api public
-   */
-  replaceWith(name, params, query) {
-    return this.doTransition("replaceURL", name, params, query);
-  }
-  /**
-   * Create an href
-   * @param  {String} name   target route name
-   * @param  {Object} [params]
-   * @param  {Object} [query]
-   * @return {String}        href
-   *
-   * @api public
-   */
-  generate(name, params, query) {
-    let matcher;
-    query = query || {};
-    this.matchers.forEach((m) => {
-      if (m.name === name) {
-        matcher = m;
+        if (e2.push({ routes: t3, name: s2.name, path: o2 }), n2[o2] && "" !== s2.path) throw new Error(`Routes ${n2[o2]} and ${s2.name} have the same url path '${o2}'`);
+        n2[o2] = s2.name;
       }
-    });
-    if (!matcher) {
-      throw new Error(`No route is named ${name}`);
-    }
-    const url = withQuery(this.options.qs, injectParams(matcher.path, params), query);
-    return this.location.formatURL(url);
+    }), this;
+  }
+  listen(t2) {
+    const e2 = this.location;
+    return e2.start(t2), e2.onChange((t3) => {
+      const e3 = this.state.path;
+      this.dispatch(t3).catch((t4) => (t4 && t4.type === L && this.location.replaceURL(e3, { trigger: false }), t4));
+    }), this.dispatch(e2.getURL());
+  }
+  transitionTo(t2, e2, n2) {
+    return this.state.activeTransition ? this.replaceWith(t2, e2, n2) : this.doTransition("setURL", t2, e2, n2);
+  }
+  replaceWith(t2, e2, n2) {
+    return this.doTransition("replaceURL", t2, e2, n2);
+  }
+  generate(t2, e2, n2) {
+    let r2;
+    if (n2 = n2 || {}, this.matchers.forEach((e3) => {
+      e3.name === t2 && (r2 = e3);
+    }), !r2) throw new Error(`No route is named ${t2}`);
+    const o2 = (function(t3, e3, n3) {
+      const r3 = t3.stringify(n3, { indices: false });
+      return r3 ? g(e3) + "?" + r3 : e3;
+    })(this.options.qs, (function(t3, e3) {
+      return e3 = e3 || {}, t3.replace(u, function(n3, r3) {
+        const o3 = r3.replace(l, ""), s2 = r3.slice(-1);
+        if ("?" === s2 || "*" === s2) {
+          if (null == e3[o3]) return "";
+        } else a(null != e3[o3], "Missing '%s' parameter for path '%s'", o3, t3);
+        let i2 = encodeURIComponent(e3[o3]);
+        return "*" !== s2 && "+" !== s2 || (i2 = i2.replace("%2F", "/")), i2;
+      });
+    })(r2.path, e2), n2);
+    return this.location.formatURL(o2);
   }
-  /**
-   * Stop listening to URL changes
-   * @api public
-   */
   destroy() {
-    if (this.location && this.location.destroy) {
-      this.location.destroy();
-    }
-    if (this.state.activeTransition) {
-      this.state.activeTransition.cancel();
-    }
-    this.state = {};
-    this.middleware.forEach((m) => {
-      m.destroy && m.destroy(this);
+    this.location && this.location.destroy && this.location.destroy(), this.state.activeTransition && this.state.activeTransition.cancel(), this.state = {}, this.middleware.forEach((t2) => {
+      t2.destroy && t2.destroy(this);
     });
   }
-  /**
-   * Check if the given route/params/query combo is active
-   * @param  {String} name   target route name
-   * @param  {Record<string, any>} [params]
-   * @param  {Record<string, any>} [query]
-   * @param  {Boolean} [exact]
-   * @return {Boolean}
-   *
-   * @api public
-   */
-  isActive(name, params, query, exact) {
-    const activeRoutes = this.state.routes || [];
-    const activeParams = this.state.params;
-    const activeQuery = this.state.query;
-    let isActive = activeRoutes.some((route) => route.name === name) && (!exact || activeRoutes[activeRoutes.length - 1].name === name);
-    isActive = isActive && (!params || keys(params).every((key) => activeParams[key] === params[key]));
-    isActive = isActive && (!query || keys(query).every((key) => activeQuery[key] === query[key]));
-    return isActive;
-  }
-  /**
-   * @api private
-   * @param  {String} method  pushState or replaceState
-   * @param  {String} name    target route name
-   * @param  {Object} [params]
-   * @param  {Object} [query]
-   * @return {Transition}         transition
-   */
-  doTransition(method, name, params, query) {
-    const previousUrl = this.location.getURL();
-    let url = name;
-    if (url[0] !== "/") {
-      url = this.generate(name, params, query);
-      url = url.replace(/^#/, "/");
-    }
-    if (this.options.pushState) {
-      url = this.location.removeRoot(url);
-    }
-    const transition2 = this.dispatch(url);
-    transition2.catch((err) => {
-      if (err && err.type === TRANSITION_CANCELLED) {
-        this.location.replaceURL(previousUrl, { trigger: false });
-      }
-      return err;
-    });
-    this.location[method](url, { trigger: false });
-    return transition2;
-  }
-  /**
-   * Match the path against the routes
-   * @param  {String} path
-   * @return {Object} the list of matching routes and params
-   *
-   * @api private
-   */
-  match(path) {
-    path = (path || "").replace(/\/$/, "") || "/";
-    let params;
-    let routes = [];
-    const pathWithoutQuery = withoutQuery(path);
-    const { qs: qs2, patternCompiler: patternCompiler2 } = this.options;
-    this.matchers.some((matcher) => {
-      params = extractParams(matcher.path, pathWithoutQuery, patternCompiler2);
-      if (params) {
-        routes = matcher.routes;
-        return true;
-      }
-    });
-    return {
-      routes: routes.map(descriptor),
-      params: params || {},
-      pathname: pathWithoutQuery,
-      query: extractQuery(qs2, path) || {}
-    };
-    function descriptor(route) {
-      return {
-        name: route.name,
-        path: route.path,
-        params: pick(params, extractParamNames(route.path, patternCompiler2)),
-        options: clone(route.options)
-      };
-    }
-  }
-  /**
-   *
-   * @param {string} path
-   * @returns {Transition}
-   */
-  dispatch(path) {
-    const match = this.match(path);
-    const query = match.query;
-    const pathname = match.pathname;
-    const activeTransition = this.state.activeTransition;
-    if (activeTransition && activeTransition.pathname === pathname && isEqual$1(activeTransition.query, query)) {
-      return activeTransition;
-    }
-    if (activeTransition) {
-      const err = new Error(TRANSITION_REDIRECTED);
-      err.type = TRANSITION_REDIRECTED;
-      err.nextPath = path;
-      activeTransition.cancel(err);
-    }
-    if (!activeTransition) {
-      if (this.state.pathname === pathname && isEqual$1(this.state.query, query)) {
-        return transition({
-          id: this.nextId++,
-          path,
-          match,
-          noop: true,
-          router: this
-        });
-      }
-    }
-    const t = transition({
-      id: this.nextId++,
-      path,
-      match,
-      router: this
-    });
-    this.state.activeTransition = t;
-    return t;
-  }
-  log(...args) {
-    console.info(...args);
-  }
-  logError(...args) {
-    console.error(...args);
+  isActive(t2, e2, n2, o2) {
+    const s2 = this.state.routes || [], i2 = this.state.params, a2 = this.state.query;
+    let c2 = s2.some((e3) => e3.name === t2) && (!o2 || s2[s2.length - 1].name === t2);
+    return c2 = c2 && (!e2 || r(e2).every((t3) => i2[t3] === e2[t3])), c2 = c2 && (!n2 || r(n2).every((t3) => a2[t3] === n2[t3])), c2;
+  }
+  doTransition(t2, e2, n2, r2) {
+    const o2 = this.location.getURL();
+    let s2 = e2;
+    "/" !== s2[0] && (s2 = this.generate(e2, n2, r2), s2 = s2.replace(/^#/, "/")), this.options.pushState && (s2 = this.location.removeRoot(s2));
+    const i2 = this.dispatch(s2);
+    return i2.catch((t3) => (t3 && t3.type === L && this.location.replaceURL(o2, { trigger: false }), t3)), this.location[t2](s2, { trigger: false }), i2;
+  }
+  match(t2) {
+    let e2;
+    t2 = (t2 || "").replace(/\/$/, "") || "/";
+    let n2 = [];
+    const r2 = g(t2), { qs: s2, patternCompiler: i2 } = this.options;
+    return this.matchers.some((t3) => {
+      if (e2 = (function(t4, e3, n3) {
+        const r3 = m(t4, n3), o2 = r3.matcher, s3 = r3.paramNames, i3 = e3.match(o2);
+        if (!i3) return null;
+        const a2 = {};
+        return s3.forEach(function(t5, e4) {
+          a2[t5] = i3[e4 + 1] && decodeURIComponent(i3[e4 + 1]);
+        }), a2;
+      })(t3.path, r2, i2), e2) return n2 = t3.routes, true;
+    }), { routes: n2.map(function(t3) {
+      return { name: t3.name, path: t3.path, params: (n3 = e2, s3 = t3.path, a2 = i2, r3 = m(s3, a2).paramNames, r3.reduce((t4, e3) => void 0 === n3[e3] ? t4 : ((t5, e4, n4) => (t5[e4] = n4, t5))(t4, e3, n3[e3]), {})), options: o(t3.options) };
+      var n3, r3;
+      var s3, a2;
+    }), params: e2 || {}, pathname: r2, query: d(s2, t2) || {} };
+  }
+  dispatch(t2) {
+    const e2 = this.match(t2), n2 = e2.query, r2 = e2.pathname, o2 = this.state.activeTransition;
+    if (o2 && o2.pathname === r2 && s(o2.query, n2)) return o2;
+    if (o2) {
+      const e3 = new Error(k);
+      e3.type = k, e3.nextPath = t2, o2.cancel(e3);
+    }
+    if (!o2 && this.state.pathname === r2 && s(this.state.query, n2)) return j({ id: this.nextId++, path: t2, match: e2, noop: true, router: this });
+    const i2 = j({ id: this.nextId++, path: t2, match: e2, router: this });
+    return this.state.activeTransition = i2, i2;
+  }
+  log(...t2) {
+    console.info(...t2);
+  }
+  logError(...t2) {
+    console.error(...t2);
   }
 };
-function defaultClickHandler(event, link, router2) {
-  event.preventDefault();
-  router2.transitionTo(router2.location.removeRoot(link.getAttribute("href")));
-}
-function interceptLinks(router2, el = document, clickHandler = defaultClickHandler) {
-  return intercept(el, (event, link) => clickHandler(event, link, router2));
-}
-const resolved = Promise.resolve();
-let routeElMap = /* @__PURE__ */ Object.create(null);
-let routeComponentMap = /* @__PURE__ */ Object.create(null);
-let routePropertiesMap = /* @__PURE__ */ Object.create(null);
-let router, rootOutlet, rootOutletEl;
-function parseNumber(value) {
-  const n = parseFloat(value);
-  const isNumeric = value == n;
-  return isNumeric ? n : value;
-}
-function getFormattedValue(value, format) {
-  let v = value;
-  if (v !== void 0) {
-    if (format === "number") {
-      v = parseNumber(value);
-    } else if (typeof format === "function") {
-      v = format(value);
-    }
-  }
-  return v;
-}
-function fromValue(value) {
-  return {
-    init(setValue) {
-      setValue(value);
-    }
-  };
-}
-function create(instance) {
-  router = instance;
-  rootOutlet = instance.options.outlet;
-}
-function destroy() {
-  router = null;
-  routeElMap = /* @__PURE__ */ Object.create(null);
-  routeComponentMap = /* @__PURE__ */ Object.create(null);
-  routePropertiesMap = /* @__PURE__ */ Object.create(null);
-  rootOutletEl = null;
-}
-function isEqual(obj1, obj2) {
-  const keys1 = Object.keys(obj1);
-  return keys1.length === Object.keys(obj2).length && keys1.every((key) => obj2[key] === obj1[key]);
-}
-function getOutlet(el) {
-  const renderRoot = el.shadowRoot || el;
-  return renderRoot.querySelector(el.constructor.outlet || "router-outlet");
-}
-function resolveRootOutlet() {
-  if (rootOutletEl) return rootOutletEl;
-  if (!rootOutlet) return document.body;
-  rootOutletEl = typeof rootOutlet === "string" ? document.querySelector(rootOutlet) : rootOutlet;
-  if (!rootOutletEl) {
-    throw new Error(`slick-router(wc): Invalid outlet option ${rootOutlet}`);
-  }
-  return rootOutletEl;
-}
-function getParentEl(transition2, parentIndex) {
-  let parent = transition2.routes[parentIndex];
-  while (parent) {
-    if (parent.options.component) {
-      return routeElMap[parent.name];
-    }
-    parent = transition2.routes[--parentIndex];
-  }
-}
-function getChangingIndex(prevRoutes, currentRoutes) {
-  let index, prev, current;
-  const count = Math.max(prevRoutes.length, currentRoutes.length);
-  for (index = 0; index < count; index++) {
-    prev = prevRoutes[index];
-    current = currentRoutes[index];
-    if (!(prev && current) || prev.name !== current.name || !isEqual(prev.params, current.params)) {
-      break;
-    }
-  }
-  return index;
-}
-function runPropertyHookMethod(transition2, routes, method) {
-  for (let i = 0; i < routes.length; i++) {
-    const { route } = routes[i];
-    const propertiesData = routePropertiesMap[route.name];
-    for (const { hooks, set } of Object.values(propertiesData)) {
-      hooks.forEach((hook) => {
-        if (typeof hook[method] === "function") {
-          hook[method](transition2, set);
-        }
-      });
-    }
-  }
-}
-async function runLifeCycle(transition2, routes, prefix, suffix) {
-  for (let i = 0; i < routes.length; i++) {
-    let result;
-    const { route, el } = routes[i];
-    const routeMethod = route.options[`${prefix}${suffix}`];
-    if (typeof routeMethod === "function") {
-      result = await routeMethod(transition2);
-      if (result === false) {
-        transition2.cancel();
-      }
-    }
-    if (transition2.isCancelled) break;
-    const elMethod = el && el[`${prefix}Route${suffix}`];
-    if (typeof elMethod === "function") {
-      result = await elMethod.call(el, transition2);
-      if (result === false) {
-        transition2.cancel();
-      }
-    }
-    if (transition2.isCancelled) break;
+function _(t2, e2, n2) {
+  t2.preventDefault(), n2.transitionTo(n2.location.removeRoot(e2.getAttribute("href")));
+}
+const I = Promise.resolve();
+let F, H, D, M = /* @__PURE__ */ Object.create(null), N = /* @__PURE__ */ Object.create(null), W = /* @__PURE__ */ Object.create(null);
+function z(t2, e2) {
+  let n2 = t2;
+  return void 0 !== n2 && ("number" === e2 ? n2 = (function(t3) {
+    const e3 = parseFloat(t3);
+    return t3 == e3 ? e3 : t3;
+  })(t2) : "function" == typeof e2 && (n2 = e2(t2))), n2;
+}
+function K(t2, e2) {
+  const n2 = Object.keys(t2);
+  return n2.length === Object.keys(e2).length && n2.every((n3) => e2[n3] === t2[n3]);
+}
+function B(t2) {
+  return (t2.shadowRoot || t2).querySelector(t2.constructor.outlet || "router-outlet");
+}
+function Z() {
+  if (D) return D;
+  if (!H) return document.body;
+  if (D = "string" == typeof H ? document.querySelector(H) : H, !D) throw new Error(`slick-router(wc): Invalid outlet option ${H}`);
+  return D;
+}
+function J(t2, e2) {
+  let n2 = t2.routes[e2];
+  for (; n2; ) {
+    if (n2.options.component) return M[n2.name];
+    n2 = t2.routes[--e2];
+  }
+}
+function V(t2, e2, n2) {
+  for (let r2 = 0; r2 < e2.length; r2++) {
+    const { route: o2 } = e2[r2], s2 = W[o2.name];
+    for (const { hooks: e3, set: r3 } of Object.values(s2)) e3.forEach((e4) => {
+      "function" == typeof e4[n2] && e4[n2](t2, r3);
+    });
   }
 }
-function resolveModule(value) {
-  return value && value.__esModule ? value.default : value;
-}
-function initPropertyHook(value) {
-  if (value && typeof value === "object") return value;
-  return fromValue(value);
-}
-function initProperties(route) {
-  let propertiesData = routePropertiesMap[route.name];
-  if (!propertiesData) {
-    propertiesData = routePropertiesMap[route.name] = /* @__PURE__ */ Object.create(null);
-    const properties = route.options.properties;
-    if (properties) {
-      for (const [name, hookOrValue] of Object.entries(properties)) {
-        const hooks = Array.isArray(hookOrValue) ? hookOrValue.map(initPropertyHook) : [initPropertyHook(hookOrValue)];
-        const set = (v, format) => {
-          const propertyData = propertiesData[name];
-          const newValue = getFormattedValue(v, format);
-          if (propertyData.value === newValue) return;
-          propertyData.value = newValue;
-          const el = routeElMap[route.name];
-          if (el) {
-            el[name] = newValue;
-          }
-          hooks.forEach((hook) => {
-            if (typeof hook.update === "function") {
-              hook.update(newValue, el);
-            }
-          });
-        };
-        propertiesData[name] = { hooks, set };
-        hooks.forEach((hook) => {
-          if (typeof hook.init === "function") {
-            hook.init(set);
-          }
+async function G(t2, e2, n2, r2) {
+  for (let o2 = 0; o2 < e2.length; o2++) {
+    let s2;
+    const { route: i2, el: a2 } = e2[o2], c2 = i2.options[`${n2}${r2}`];
+    if ("function" == typeof c2 && (s2 = await c2(t2), false === s2 && t2.cancel()), t2.isCancelled) break;
+    const h2 = a2 && a2[`${n2}Route${r2}`];
+    if ("function" == typeof h2 && (s2 = await h2.call(a2, t2), false === s2 && t2.cancel()), t2.isCancelled) break;
+  }
+}
+function Q(t2) {
+  return t2 && t2.__esModule ? t2.default : t2;
+}
+function X(t2) {
+  return t2 && "object" == typeof t2 ? t2 : /* @__PURE__ */ (function(t3) {
+    return { init(e2) {
+      e2(t3);
+    } };
+  })(t2);
+}
+function Y(t2) {
+  let e2 = W[t2.name];
+  if (!e2) {
+    e2 = W[t2.name] = /* @__PURE__ */ Object.create(null);
+    const n2 = t2.options.properties;
+    if (n2) for (const [r2, o2] of Object.entries(n2)) {
+      const n3 = Array.isArray(o2) ? o2.map(X) : [X(o2)], s2 = (o3, s3) => {
+        const i2 = e2[r2], a2 = z(o3, s3);
+        if (i2.value === a2) return;
+        i2.value = a2;
+        const c2 = M[t2.name];
+        c2 && (c2[r2] = a2), n3.forEach((t3) => {
+          "function" == typeof t3.update && t3.update(a2, c2);
         });
-      }
-    }
-  }
-}
-async function resolveRoutes(routes) {
-  const result = [];
-  for (const route of routes) {
-    let el = route.options.reuse ? routeElMap[route.name] : void 0;
-    let Component = route.options.component;
-    if (!el && Component) {
-      if (typeof Component === "function" && !(Component.prototype instanceof HTMLElement)) {
-        Component = routeComponentMap[route.name] || (routeComponentMap[route.name] = resolveModule(await Component(route)));
-      }
-      el = typeof Component === "string" ? document.createElement(Component) : new Component();
-      routeElMap[route.name] = el;
-      el.$router = router;
+      };
+      e2[r2] = { hooks: n3, set: s2 }, n3.forEach((t3) => {
+        "function" == typeof t3.init && t3.init(s2);
+      });
     }
-    initProperties(route);
-    result.push({ el, route });
   }
-  return result;
 }
-function applyProperties(el, route) {
-  const propertiesData = routePropertiesMap[route.name];
-  Object.entries(propertiesData).forEach(([name, { value }]) => {
-    el[name] = value;
+function tt(t2, e2) {
+  const n2 = W[e2.name];
+  Object.entries(n2).forEach(([e3, { value: n3 }]) => {
+    t2[e3] = n3;
   });
 }
-const removedEls = /* @__PURE__ */ new WeakSet();
-const outletCurrentEl = /* @__PURE__ */ new WeakMap();
-async function renderElements(transition2, activated, changingIndex) {
-  const { path, pathname, routes, params, query } = transition2;
-  const routeState = { path, pathname, routes, params, query };
-  for (let k = 0; k < changingIndex; k++) {
-    const route = transition2.routes[k];
-    const el = routeElMap[route.name];
-    if (el) {
-      el.$route = routeState;
-      applyProperties(el, route);
-    }
-  }
-  for (let i = 0; i < activated.length; i++) {
-    const { el, route } = activated[i];
-    if (el) {
-      const parentEl = getParentEl(transition2, changingIndex + i - 1);
-      const outletEl = parentEl ? getOutlet(parentEl) : resolveRootOutlet();
-      if (outletEl) {
-        const currentEl = outletCurrentEl.get(outletEl) || outletEl.firstElementChild;
-        if (currentEl) {
-          outletEl.removeChild(currentEl);
-          removedEls.add(currentEl);
+const et = /* @__PURE__ */ new WeakSet(), nt = /* @__PURE__ */ new WeakMap();
+const rt = { create: function(t2) {
+  F = t2, H = t2.options.outlet;
+}, destroy: function() {
+  F = null, M = /* @__PURE__ */ Object.create(null), N = /* @__PURE__ */ Object.create(null), W = /* @__PURE__ */ Object.create(null), D = null;
+}, resolve: async function(t2) {
+  const e2 = t2.prev.routes, n2 = (function(t3, e3) {
+    let n3, r3, o3;
+    const s2 = Math.max(t3.length, e3.length);
+    for (n3 = 0; n3 < s2 && (r3 = t3[n3], o3 = e3[n3], r3 && o3 && r3.name === o3.name && K(r3.params, o3.params)); n3++) ;
+    return n3;
+  })(e2, t2.routes), r2 = [];
+  for (let t3 = e2.length - 1; t3 >= n2; t3--) {
+    const n3 = e2[t3];
+    r2.push({ el: M[n3.name], route: n3 });
+  }
+  if (await G(t2, r2, "before", "Leave"), t2.isCancelled) return;
+  const o2 = await (async function(t3) {
+    const e3 = [];
+    for (const n3 of t3) {
+      let t4 = n3.options.reuse ? M[n3.name] : void 0, r3 = n3.options.component;
+      !t4 && r3 && ("function" != typeof r3 || r3.prototype instanceof HTMLElement || (r3 = N[n3.name] || (N[n3.name] = Q(await r3(n3)))), t4 = "string" == typeof r3 ? document.createElement(r3) : new r3(), M[n3.name] = t4, t4.$router = F), Y(n3), e3.push({ el: t4, route: n3 });
+    }
+    return e3;
+  })(t2.routes.slice(n2));
+  await G(t2, o2, "before", "Enter"), t2.isCancelled || (V(t2, o2, "enter"), await (async function(t3, e3, n3) {
+    const { path: r3, pathname: o3, routes: s2, params: i2, query: a2 } = t3, c2 = { path: r3, pathname: o3, routes: s2, params: i2, query: a2 };
+    for (let e4 = 0; e4 < n3; e4++) {
+      const n4 = t3.routes[e4], r4 = M[n4.name];
+      r4 && (r4.$route = c2, tt(r4, n4));
+    }
+    for (let r4 = 0; r4 < e3.length; r4++) {
+      const { el: o4, route: s3 } = e3[r4];
+      if (o4) {
+        const e4 = J(t3, n3 + r4 - 1), i3 = e4 ? B(e4) : Z();
+        if (i3) {
+          const t4 = nt.get(i3) || i3.firstElementChild;
+          t4 && (i3.removeChild(t4), et.add(t4)), o4.$route = c2, tt(o4, s3), i3.appendChild(o4), nt.set(i3, o4), await (o4.updateComplete || I);
         }
-        el.$route = routeState;
-        applyProperties(el, route);
-        outletEl.appendChild(el);
-        outletCurrentEl.set(outletEl, el);
-        await (el.updateComplete || resolved);
-      }
-    }
-  }
-}
-function updateDOMTree(activated, deactivated) {
-  let parentElRemoved;
-  for (let routeIndex = deactivated.length - 1; routeIndex >= 0; routeIndex--) {
-    const { route, el } = deactivated[routeIndex];
-    if (!activated.some(({ route: activeRoute }) => activeRoute.name === route.name)) {
-      if (el) {
-        if (!parentElRemoved && !removedEls.has(el)) el.remove();
-        parentElRemoved = true;
       }
-      routeElMap[route.name] = void 0;
     }
-  }
-}
-async function resolve(transition2) {
-  const prevRoutes = transition2.prev.routes;
-  const changingIndex = getChangingIndex(prevRoutes, transition2.routes);
-  const deactivated = [];
-  for (let routeIndex = prevRoutes.length - 1; routeIndex >= changingIndex; routeIndex--) {
-    const route = prevRoutes[routeIndex];
-    deactivated.push({ el: routeElMap[route.name], route });
-  }
-  await runLifeCycle(transition2, deactivated, "before", "Leave");
-  if (transition2.isCancelled) return;
-  const activated = await resolveRoutes(transition2.routes.slice(changingIndex));
-  await runLifeCycle(transition2, activated, "before", "Enter");
-  if (transition2.isCancelled) return;
-  runPropertyHookMethod(transition2, activated, "enter");
-  await renderElements(transition2, activated, changingIndex);
-  updateDOMTree(activated, deactivated);
-  transition2.activated = activated;
-  transition2.deactivated = deactivated;
-}
-function done(transition2) {
-  runPropertyHookMethod(transition2, transition2.deactivated, "leave");
-  runLifeCycle(transition2, transition2.deactivated, "after", "Leave");
-  runLifeCycle(transition2, transition2.activated, "after", "Enter");
-}
-const wc = {
-  create,
-  destroy,
-  resolve,
-  done
-};
-class Router2 extends Router$1 {
-  constructor(options) {
-    super(options);
-    this.use(wc);
-    this.use(routerLinks);
-  }
-}
-let eventPrefix;
-function trigger(name, detail) {
-  window.dispatchEvent(new CustomEvent(`${eventPrefix}${name}`, { detail }));
-}
-const events = {
-  create: function(router2) {
-    eventPrefix = router2.options.eventPrefix || "router-";
-  },
-  before: function(transition2) {
-    trigger("before:transition", { transition: transition2 });
-  },
-  done: function(transition2) {
-    trigger("transition", { transition: transition2 });
-  },
-  cancel: function(transition2, error) {
-    if (error.type !== "TransitionRedirected") {
-      trigger("abort", { transition: transition2, error });
-    }
-  },
-  error: function(transition2, error) {
-    trigger("abort", { transition: transition2, error });
-    trigger("error", { transition: transition2, error });
-  }
-};
-class Routerx extends WJElement {
-  /**
-   * Creates an instance of Routerx.
-   * @class
-   */
+  })(t2, o2, n2), (function(t3, e3) {
+    let n3;
+    for (let r3 = e3.length - 1; r3 >= 0; r3--) {
+      const { route: o3, el: s2 } = e3[r3];
+      t3.some(({ route: t4 }) => t4.name === o3.name) || (s2 && (n3 || et.has(s2) || s2.remove(), n3 = true), M[o3.name] = void 0);
+    }
+  })(o2, r2), t2.activated = o2, t2.deactivated = r2);
+}, done: function(t2) {
+  V(t2, t2.deactivated, "leave"), G(t2, t2.deactivated, "after", "Leave"), G(t2, t2.activated, "after", "Enter");
+} };
+class ot extends A {
+  constructor(e2) {
+    super(e2), this.use(rt), this.use(t);
+  }
+}
+let st;
+function it(t2, e2) {
+  window.dispatchEvent(new CustomEvent(`${st}${t2}`, { detail: e2 }));
+}
+const at = { create: function(t2) {
+  st = t2.options.eventPrefix || "router-";
+}, before: function(t2) {
+  it("before:transition", { transition: t2 });
+}, done: function(t2) {
+  it("transition", { transition: t2 });
+}, cancel: function(t2, e2) {
+  "TransitionRedirected" !== e2.type && it("abort", { transition: t2, error: e2 });
+}, error: function(t2, e2) {
+  it("abort", { transition: t2, error: e2 }), it("error", { transition: t2, error: e2 });
+} };
+class ct extends e {
   constructor() {
     super();
-    __privateAdd(this, _routes);
+    __privateAdd(this, _t);
     __publicField(this, "className", "Routerx");
-    /**
-     * Sets the breadcrumb for the transition.
-     * @param {object} transition The transition object.
-     */
-    __publicField(this, "setBreadcrumb", (transition2) => {
-      let breadcrumb = [
-        ...transition2.routes.filter((obj) => "breadcrumb" in obj.options).map((b, i) => {
-          var _a, _b;
-          return {
-            name: b.options.breadcrumbPath || b.name,
-            text: b.options.breadcrumb instanceof Function ? (_b = (_a = b.options).breadcrumb) == null ? void 0 : _b.call(_a, transition2) : b.options.breadcrumb,
-            params: { ...b.params, ...transition2.params },
-            path: this.router.generate(b.name, { ...b.params, ...transition2.params })
-          };
-        })
-      ];
-      transition2.breadcrumbs = breadcrumb;
+    __publicField(this, "setBreadcrumb", (t2) => {
+      let e2 = [...t2.routes.filter((t3) => "breadcrumb" in t3.options).map((e3, n2) => {
+        var _a, _b;
+        return { name: e3.options.breadcrumbPath || e3.name, text: e3.options.breadcrumb instanceof Function ? (_b = (_a = e3.options).breadcrumb) == null ? void 0 : _b.call(_a, t2) : e3.options.breadcrumb, params: { ...e3.params, ...t2.params }, path: this.router.generate(e3.name, { ...e3.params, ...t2.params }) };
+      })];
+      t2.breadcrumbs = e2;
     });
-    /**
-     * Resets the scroll position.
-     * @param {object} transition The transition object.
-     */
-    __publicField(this, "resetScrollPosition", (transition2) => {
+    __publicField(this, "resetScrollPosition", (t2) => {
       window.scrollTo(0, 0);
     });
   }
-  set routes(value) {
-    __privateSet(this, _routes, value);
+  set routes(t2) {
+    __privateSet(this, _t, t2);
   }
   get routes() {
     return this.parseElement(this.rootElement).root;
   }
   get rootElement() {
-    const htmlString = this.outerHTML;
-    const parser = new DOMParser();
-    const htmlDocument = parser.parseFromString(htmlString, "text/html");
-    return htmlDocument.querySelector("wje-router");
-  }
-  /**
-   * Returns the list of attributes to observe for changes.
-   * @static
-   * @returns {Array<string>}
-   */
+    const t2 = this.outerHTML;
+    return new DOMParser().parseFromString(t2, "text/html").querySelector("wje-router");
+  }
   static get observedAttributes() {
     return [];
   }
-  /**
-   * Sets up the attributes for the component.
-   */
   setupAttributes() {
     this.isShadowRoot = "open";
   }
-  /**
-   * Sets up the router after the component is drawn.
-   */
   beforeDraw() {
-    this.router = new Router2({
-      outlet: this.outlet || "wje-router-outlet",
-      log: false,
-      logError: false,
-      root: this.root || "/",
-      pushState: true
-    });
-    this.router.map(this.routes);
-    this.router.use(this.setBreadcrumb);
-    this.router.use(events);
-    this.router.use(this.resetScrollPosition);
-    this.router.listen();
-    this.unbindIntercept = interceptLinks(this.router);
-  }
-  /**
-   * Parses an element and returns an object representation.
-   * @param {Element} element The element to parse.
-   * @returns {object} The object representation of the element.
-   */
-  parseElement(element) {
-    const obj = {};
-    const attributes = element.attributes;
-    for (let i = 0; i < attributes.length; i++) {
-      const attributeName = attributes[i].name;
-      const attributeValue = attributes[i].value;
-      if (attributeName === "component" && attributeValue.indexOf(".js") > -1) {
-        obj.component = () => import(
-          /* @vite-ignore */
-          attributeValue
-        );
-      } else {
-        if (attributeName !== "shadow") {
-          const camelCase = attributeName.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-          obj[camelCase] = attributeValue;
-        }
+    this.router = new ot({ outlet: this.outlet || "wje-router-outlet", log: false, logError: false, root: this.root || "/", pushState: true }), this.router.map(this.routes), this.router.use(this.setBreadcrumb), this.router.use(at), this.router.use(this.resetScrollPosition), this.router.listen(), this.unbindIntercept = (function(t2, e2 = document, n2 = _) {
+      return S(e2, (e3, r2) => n2(e3, r2, t2));
+    })(this.router);
+  }
+  parseElement(t2) {
+    const e2 = {}, n2 = t2.attributes;
+    for (let t3 = 0; t3 < n2.length; t3++) {
+      const r3 = n2[t3].name, o2 = n2[t3].value;
+      if ("component" === r3 && o2.indexOf(".js") > -1) e2.component = () => import(o2);
+      else if ("shadow" !== r3) {
+        e2[r3.replace(/-([a-z])/g, (t4) => t4[1].toUpperCase())] = o2;
       }
     }
-    const children = [];
-    const childElements = Array.from(element.children);
-    childElements.forEach((childElement) => {
-      children.push(this.parseElement(childElement));
-    });
-    if (children.length > 0 && element.tagName === "WJE-ROUTE") {
-      obj.children = children;
-    } else {
-      obj.root = children;
-    }
-    return obj;
+    const r2 = [];
+    return Array.from(t2.children).forEach((t3) => {
+      r2.push(this.parseElement(t3));
+    }), r2.length > 0 && "WJE-ROUTE" === t2.tagName ? e2.children = r2 : e2.root = r2, e2;
   }
-  /**
-   * Cleans up before the component is disconnected.
-   */
   beforeDisconnect() {
-    this.unbindIntercept();
-    this.router.destroy();
+    this.unbindIntercept(), this.router.destroy();
   }
 }
-_routes = new WeakMap();
-Routerx.define("wje-router", Routerx);
+_t = new WeakMap();
+ct.define("wje-router", ct);
 export {
-  Routerx as default
+  ct as default
 };
 //# sourceMappingURL=wje-routerx.js.map