{"version":3,"sources":["../../node_modules/@vaadin/router/dist/vaadin-router.js","src/utils/router-utils.ts"],"names":["toArray","objectOrArray","Array","isArray","log","msg","logValue","value","String","stringType","Object","prototype","toString","call","match","JSON","stringify","MODULE","NOMODULE","bundleKeys","ensureBundle","src","Error","ensureRoute","route","isString","path","bundle","stringKeys","isFunction","action","children","isObject","some","key","join","forEach","redirect","overriddenProp","console","warn","ensureRoutes","routes","loadScript","script","document","head","querySelector","createElement","setAttribute","async","Promise","resolve","reject","onreadystatechange","onload","e","__dynamicImportLoaded","onerror","parentNode","removeChild","appendChild","loadBundle","race","filter","map","fireRouterEvent","type","detail","window","dispatchEvent","CustomEvent","cancelable","o","f","s","getNotFoundError","context","error","pathname","code","notFoundResult","NotFoundResult","getAnchorOrigin","anchor","port","protocol","defaultHttp","defaultHttps","host","hostname","vaadinRouterGlobalClickHandler","event","defaultPrevented","button","shiftKey","ctrlKey","altKey","metaKey","target","composedPath","i","length","nodeName","toLowerCase","hasAttribute","location","hash","origin","search","preventDefault","scrollTo","CLICK","[object Object]","addEventListener","removeEventListener","isIE","test","navigator","userAgent","PopStateEvent","inType","params","createEvent","initEvent","Boolean","bubbles","state","Event","vaadinRouterGlobalPopstateHandler","POPSTATE","pathToRegexp_1","pathToRegexp$1","parse_1","parse","compile_1","compile","tokensToFunction_1","tokensToFunction","tokensToRegExp_1","tokensToRegExp","DEFAULT_DELIMITER","DEFAULT_DELIMITERS","PATH_REGEXP","RegExp","str","options","tokens","index","defaultDelimiter","delimiter","delimiters","pathEscaped","res","exec","m","escaped","offset","slice","prev","next","name","capture","group","modifier","k","indexOf","push","partial","undefined","repeat","optional","pattern","prefix","escapeGroup","escapeString","substr","matches","data","encode","encodeURIComponent","token","segment","TypeError","j","replace","flags","sensitive","regexpToRegexp","keys","groups","source","arrayToRegexp","parts","stringToRegexp","strict","start","end","endsWith","concat","isEndDelimited","hasOwnProperty","cache$1","Map","set","decodeParam","val","decodeURIComponent","err","matchPath","routepath","exact","parentKeys","parentParams","cacheKey","regexp","get","assign","prop","split","matchRoute","ignoreLeadingSlash","childMatches","childIndex","charAt","routeToSkip","done","__children","childRoute","parent","matchedLength","childMatch","resolveRoute","isChildRoute","parentRoute","generateErrorMessage","currentContext","errorMessage","routePath","updateChainForRoute","__synthetic","item","chain","pop","Resolver","this","baseUrl","errorHandler","resolver","root","newRoutes","getRoutes","setRoutes","pathnameOrContext","__normalizePathname","nextMatches","resume","prevResult","then","resolution","result","catch","DOMException","url","base","URL","__effectiveBaseUrl","constructor","__createUrl","baseURI","href","normalizedUrl","pathToRegexp","cache","cacheRoutes","routesByName","component","has","getRouteByName","routeName","getRoutePath","generateUrls","router","clear","fullPath","rt","toPath","create","stringifyQueryParams","queryParams","query","triggers","setNavigationTriggers","newTriggers","trigger","inactivate","activate","willAnimate","elem","getComputedStyle","getPropertyValue","waitForAnimation","cb","listener","animate","className","classList","add","rect","getBoundingClientRect","size","bottom","top","right","left","remove","removeAttribute","MAX_REDIRECT_COUNT","isResultNotEmpty","copyContextWithoutNext","copy","createLocation","redirectFrom","getUrl","userParams","getPathnameForRouter","Router","getMatchedPath","createRedirect","from","renderElement","element","runCallbackIfPossible","callback","args","thisArg","apply","amend","amendmentFunction","amendmentResult","cancel","processNewChildren","newChildren","childRoutes","removeDomNodes","nodes","reduce","a","b","outlet","baseElement","baseHref","getAttribute","super","__resolveRoute","NavigationTrigger","setTriggers","ready","__lastStartedRenderId","__navigationEventHandler","__onNavigationEvent","bind","setOutlet","subscribe","__createdByRouter","WeakMap","__addedByRouter","callbacks","commands","__isLatestRender","HTMLElement","__ensureOutlet","__outlet","skipRender","__previousContext","__urlForName","shouldUpdateHistory","renderId","__renderId","__fullyResolveChain","previousContext","__updateBrowserHistory","__skipAttach","__copyUnchangedElements","__addAppearingContent","animationDone","__animateIfNeeded","__runOnAfterEnterCallbacks","__runOnAfterLeaveCallbacks","__removeDisappearingContent","topOfTheChainContextBeforeRedirects","contextBeforeRedirects","__findComponentContextAfterAllRedirects","contextAfterRedirects","redirectsHappened","topOfTheChainContextAfterRedirects","matchedPath","isFound","findNextContextIfAny","nextContext","__amendWithOnBeforeCallbacks","__redirect","__redirectCount","contextWithFullChain","__runOnBeforeCallbacks","amendedContext","newContext","previousChain","newChain","prevent","__divergedChainIndex","Math","min","__isReusableElement","__runOnBeforeLeaveCallbacks","__runOnBeforeEnterCallbacks","chainElement","afterLeaveFunction","beforeEnterFunction","otherElement","localName","redirectData","counter","urlForPath","Node","changeState","history","title","deepestCommonParent","unchangedElement","__removeAppearingContent","__appearingContent","__disappearingContent","parentElement","elementToAdd","targetContext","currentComponent","onAfterLeave","onAfterEnter","to","promises","config","leave","enter","all","render","DEV_MODE_CODE_REGEXP","FlowClients","Vaadin","Flow","clients","isMinified","uncommentAndRun","isDevelopmentMode","isForcedDevelopmentMode","isLocalhost","isFlowProductionMode","localStorage","getItem","productionModeApps","client","productionMode","Function","runIfDevelopmentMode","developmentMode","maybeGatherAndSendStats","usageStatistics","registrations","is","version","BlogRoutes","getRouter","urlFor","urlForName","message","HOME","removeBaseUrl","go","goToPath"],"mappings":"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","sourcesContent":["function toArray(objectOrArray) {\n  objectOrArray = objectOrArray || [];\n  return Array.isArray(objectOrArray) ? objectOrArray : [objectOrArray];\n}\n\nfunction log(msg) {\n  return `[Vaadin.Router] ${msg}`;\n}\n\nfunction logValue(value) {\n  if (typeof value !== 'object') {\n    return String(value);\n  }\n\n  const stringType = Object.prototype.toString.call(value).match(/ (.*)\\]$/)[1];\n  if (stringType === 'Object' || stringType === 'Array') {\n    return `${stringType} ${JSON.stringify(value)}`;\n  } else {\n    return stringType;\n  }\n}\n\nconst MODULE = 'module';\nconst NOMODULE = 'nomodule';\nconst bundleKeys = [MODULE, NOMODULE];\n\nfunction ensureBundle(src) {\n  if (!src.match(/.+\\.[m]?js$/)) {\n    throw new Error(\n      log(`Unsupported type for bundle \"${src}\": .js or .mjs expected.`)\n    );\n  }\n}\n\nfunction ensureRoute(route) {\n  if (!route || !isString(route.path)) {\n    throw new Error(\n      log(`Expected route config to be an object with a \"path\" string property, or an array of such objects`)\n    );\n  }\n\n  const bundle = route.bundle;\n\n  const stringKeys = ['component', 'redirect', 'bundle'];\n  if (\n    !isFunction(route.action) &&\n    !Array.isArray(route.children) &&\n    !isFunction(route.children) &&\n    !isObject(bundle) &&\n    !stringKeys.some(key => isString(route[key]))\n  ) {\n    throw new Error(\n      log(\n        `Expected route config \"${route.path}\" to include either \"${stringKeys.join('\", \"')}\" ` +\n        `or \"action\" function but none found.`\n      )\n    );\n  }\n\n  if (bundle) {\n    if (isString(bundle)) {\n      ensureBundle(bundle);\n    } else if (!bundleKeys.some(key => key in bundle)) {\n      throw new Error(\n        log('Expected route bundle to include either \"' + NOMODULE + '\" or \"' + MODULE + '\" keys, or both')\n      );\n    } else {\n      bundleKeys.forEach(key => key in bundle && ensureBundle(bundle[key]));\n    }\n  }\n\n  if (route.redirect) {\n    ['bundle', 'component'].forEach(overriddenProp => {\n      if (overriddenProp in route) {\n        console.warn(\n          log(\n            `Route config \"${route.path}\" has both \"redirect\" and \"${overriddenProp}\" properties, ` +\n            `and \"redirect\" will always override the latter. Did you mean to only use \"${overriddenProp}\"?`\n          )\n        );\n      }\n    });\n  }\n}\n\nfunction ensureRoutes(routes) {\n  toArray(routes).forEach(route => ensureRoute(route));\n}\n\nfunction loadScript(src, key) {\n  let script = document.head.querySelector('script[src=\"' + src + '\"][async]');\n  if (!script) {\n    script = document.createElement('script');\n    script.setAttribute('src', src);\n    if (key === MODULE) {\n      script.setAttribute('type', MODULE);\n    } else if (key === NOMODULE) {\n      script.setAttribute(NOMODULE, '');\n    }\n    script.async = true;\n  }\n  return new Promise((resolve, reject) => {\n    script.onreadystatechange = script.onload = e => {\n      script.__dynamicImportLoaded = true;\n      resolve(e);\n    };\n    script.onerror = e => {\n      if (script.parentNode) {\n        script.parentNode.removeChild(script);\n      }\n      reject(e);\n    };\n    if (script.parentNode === null) {\n      document.head.appendChild(script);\n    } else if (script.__dynamicImportLoaded) {\n      resolve();\n    }\n  });\n}\n\nfunction loadBundle(bundle) {\n  if (isString(bundle)) {\n    return loadScript(bundle);\n  } else {\n    return Promise.race(\n      bundleKeys\n        .filter(key => key in bundle)\n        .map(key => loadScript(bundle[key], key))\n    );\n  }\n}\n\nfunction fireRouterEvent(type, detail) {\n  return !window.dispatchEvent(new CustomEvent(\n    `vaadin-router-${type}`,\n    {cancelable: type === 'go', detail}\n  ));\n}\n\nfunction isObject(o) {\n  // guard against null passing the typeof check\n  return typeof o === 'object' && !!o;\n}\n\nfunction isFunction(f) {\n  return typeof f === 'function';\n}\n\nfunction isString(s) {\n  return typeof s === 'string';\n}\n\nfunction getNotFoundError(context) {\n  const error = new Error(log(`Page not found (${context.pathname})`));\n  error.context = context;\n  error.code = 404;\n  return error;\n}\n\nconst notFoundResult = new (class NotFoundResult {})();\n\n/* istanbul ignore next: coverage is calculated in Chrome, this code is for IE */\nfunction getAnchorOrigin(anchor) {\n  // IE11: on HTTP and HTTPS the default port is not included into\n  // window.location.origin, so won't include it here either.\n  const port = anchor.port;\n  const protocol = anchor.protocol;\n  const defaultHttp = protocol === 'http:' && port === '80';\n  const defaultHttps = protocol === 'https:' && port === '443';\n  const host = (defaultHttp || defaultHttps)\n    ? anchor.hostname // does not include the port number (e.g. www.example.org)\n    : anchor.host; // does include the port number (e.g. www.example.org:80)\n  return `${protocol}//${host}`;\n}\n\n// The list of checks is not complete:\n//  - SVG support is missing\n//  - the 'rel' attribute is not considered\nfunction vaadinRouterGlobalClickHandler(event) {\n  // ignore the click if the default action is prevented\n  if (event.defaultPrevented) {\n    return;\n  }\n\n  // ignore the click if not with the primary mouse button\n  if (event.button !== 0) {\n    return;\n  }\n\n  // ignore the click if a modifier key is pressed\n  if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey) {\n    return;\n  }\n\n  // find the <a> element that the click is at (or within)\n  let anchor = event.target;\n  const path = event.composedPath\n    ? event.composedPath()\n    : (event.path || []);\n\n  // FIXME(web-padawan): `Symbol.iterator` used by webcomponentsjs is broken for arrays\n  // example to check: `for...of` loop here throws the \"Not yet implemented\" error\n  for (let i = 0; i < path.length; i++) {\n    const target = path[i];\n    if (target.nodeName && target.nodeName.toLowerCase() === 'a') {\n      anchor = target;\n      break;\n    }\n  }\n\n  while (anchor && anchor.nodeName.toLowerCase() !== 'a') {\n    anchor = anchor.parentNode;\n  }\n\n  // ignore the click if not at an <a> element\n  if (!anchor || anchor.nodeName.toLowerCase() !== 'a') {\n    return;\n  }\n\n  // ignore the click if the <a> element has a non-default target\n  if (anchor.target && anchor.target.toLowerCase() !== '_self') {\n    return;\n  }\n\n  // ignore the click if the <a> element has the 'download' attribute\n  if (anchor.hasAttribute('download')) {\n    return;\n  }\n\n  // ignore the click if the <a> element has the 'router-ignore' attribute\n  if (anchor.hasAttribute('router-ignore')) {\n    return;\n  }\n\n  // ignore the click if the target URL is a fragment on the current page\n  if (anchor.pathname === window.location.pathname && anchor.hash !== '') {\n    return;\n  }\n\n  // ignore the click if the target is external to the app\n  // In IE11 HTMLAnchorElement does not have the `origin` property\n  const origin = anchor.origin || getAnchorOrigin(anchor);\n  if (origin !== window.location.origin) {\n    return;\n  }\n\n  // if none of the above, convert the click into a navigation event\n  const {pathname, search, hash} = anchor;\n  if (fireRouterEvent('go', {pathname, search, hash})) {\n    event.preventDefault();\n    // for a click event, the scroll is reset to the top position.\n    if (event && event.type === 'click') {\n      window.scrollTo(0, 0);\n    }\n  }\n}\n\n/**\n * A navigation trigger for Vaadin Router that translated clicks on `<a>` links\n * into Vaadin Router navigation events.\n *\n * Only regular clicks on in-app links are translated (primary mouse button, no\n * modifier keys, the target href is within the app's URL space).\n *\n * @memberOf Router.NavigationTrigger\n * @type {NavigationTrigger}\n */\nconst CLICK = {\n  activate() {\n    window.document.addEventListener('click', vaadinRouterGlobalClickHandler);\n  },\n\n  inactivate() {\n    window.document.removeEventListener('click', vaadinRouterGlobalClickHandler);\n  }\n};\n\n// PopStateEvent constructor shim\nconst isIE = /Trident/.test(navigator.userAgent);\n\n/* istanbul ignore next: coverage is calculated in Chrome, this code is for IE */\nif (isIE && !isFunction(window.PopStateEvent)) {\n  window.PopStateEvent = function(inType, params) {\n    params = params || {};\n    var e = document.createEvent('Event');\n    e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable));\n    e.state = params.state || null;\n    return e;\n  };\n  window.PopStateEvent.prototype = window.Event.prototype;\n}\n\nfunction vaadinRouterGlobalPopstateHandler(event) {\n  if (event.state === 'vaadin-router-ignore') {\n    return;\n  }\n  const {pathname, search, hash} = window.location;\n  fireRouterEvent('go', {pathname, search, hash});\n}\n\n/**\n * A navigation trigger for Vaadin Router that translates popstate events into\n * Vaadin Router navigation events.\n *\n * @memberOf Router.NavigationTrigger\n * @type {NavigationTrigger}\n */\nconst POPSTATE = {\n  activate() {\n    window.addEventListener('popstate', vaadinRouterGlobalPopstateHandler);\n  },\n\n  inactivate() {\n    window.removeEventListener('popstate', vaadinRouterGlobalPopstateHandler);\n  }\n};\n\n/**\n * Expose `pathToRegexp`.\n */\nvar pathToRegexp_1 = pathToRegexp$1;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * Default configs.\n */\nvar DEFAULT_DELIMITER = '/';\nvar DEFAULT_DELIMITERS = './';\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \":test(\\\\d+)?\" => [\"test\", \"\\d+\", undefined, \"?\"]\n  // \"(\\\\d+)\"  => [undefined, undefined, \"\\d+\", undefined]\n  '(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = (options && options.delimiter) || DEFAULT_DELIMITER;\n  var delimiters = (options && options.delimiters) || DEFAULT_DELIMITERS;\n  var pathEscaped = false;\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) !== null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      pathEscaped = true;\n      continue\n    }\n\n    var prev = '';\n    var next = str[index];\n    var name = res[2];\n    var capture = res[3];\n    var group = res[4];\n    var modifier = res[5];\n\n    if (!pathEscaped && path.length) {\n      var k = path.length - 1;\n\n      if (delimiters.indexOf(path[k]) > -1) {\n        prev = path[k];\n        path = path.slice(0, k);\n      }\n    }\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n      pathEscaped = false;\n    }\n\n    var partial = prev !== '' && next !== undefined && next !== prev;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = prev || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prev,\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      pattern: pattern ? escapeGroup(pattern) : '[^' + escapeString(delimiter) + ']+?'\n    });\n  }\n\n  // Push any remaining characters.\n  if (path || index < str.length) {\n    tokens.push(path + str.substr(index));\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options))\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n    }\n  }\n\n  return function (data, options) {\n    var path = '';\n    var encode = (options && options.encode) || encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n        continue\n      }\n\n      var value = data ? data[token.name] : undefined;\n      var segment;\n\n      if (Array.isArray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but got array')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) continue\n\n          throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j], token);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\"')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n        segment = encode(String(value), token);\n\n        if (!matches[i].test(segment)) {\n          throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but got \"' + segment + '\"')\n        }\n\n        path += token.prefix + segment;\n        continue\n      }\n\n      if (token.optional) {\n        // Prepend partial segment prefixes.\n        if (token.partial) path += token.prefix;\n\n        continue\n      }\n\n      throw new TypeError('Expected \"' + token.name + '\" to be ' + (token.repeat ? 'an array' : 'a string'))\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$/()])/g, '\\\\$1')\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {Array=}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  if (!keys) return path\n\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        pattern: null\n      });\n    }\n  }\n\n  return path\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array=}  keys\n * @param  {Object=} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp$1(path[i], keys, options).source);\n  }\n\n  return new RegExp('(?:' + parts.join('|') + ')', flags(options))\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {Array=}  keys\n * @param  {Object=} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}  tokens\n * @param  {Array=}  keys\n * @param  {Object=} options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  options = options || {};\n\n  var strict = options.strict;\n  var start = options.start !== false;\n  var end = options.end !== false;\n  var delimiter = escapeString(options.delimiter || DEFAULT_DELIMITER);\n  var delimiters = options.delimiters || DEFAULT_DELIMITERS;\n  var endsWith = [].concat(options.endsWith || []).map(escapeString).concat('$').join('|');\n  var route = start ? '^' : '';\n  var isEndDelimited = tokens.length === 0;\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n      isEndDelimited = i === tokens.length - 1 && delimiters.indexOf(token[token.length - 1]) > -1;\n    } else {\n      var capture = token.repeat\n        ? '(?:' + token.pattern + ')(?:' + escapeString(token.delimiter) + '(?:' + token.pattern + '))*'\n        : token.pattern;\n\n      if (keys) keys.push(token);\n\n      if (token.optional) {\n        if (token.partial) {\n          route += escapeString(token.prefix) + '(' + capture + ')?';\n        } else {\n          route += '(?:' + escapeString(token.prefix) + '(' + capture + '))?';\n        }\n      } else {\n        route += escapeString(token.prefix) + '(' + capture + ')';\n      }\n    }\n  }\n\n  if (end) {\n    if (!strict) route += '(?:' + delimiter + ')?';\n\n    route += endsWith === '$' ? '$' : '(?=' + endsWith + ')';\n  } else {\n    if (!strict) route += '(?:' + delimiter + '(?=' + endsWith + '))?';\n    if (!isEndDelimited) route += '(?=' + delimiter + '|' + endsWith + ')';\n  }\n\n  return new RegExp(route, flags(options))\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {Array=}                keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp$1 (path, keys, options) {\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, keys)\n  }\n\n  if (Array.isArray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), keys, options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), keys, options)\n}\npathToRegexp_1.parse = parse_1;\npathToRegexp_1.compile = compile_1;\npathToRegexp_1.tokensToFunction = tokensToFunction_1;\npathToRegexp_1.tokensToRegExp = tokensToRegExp_1;\n\n/**\n * Universal Router (https://www.kriasoft.com/universal-router/)\n *\n * Copyright (c) 2015-present Kriasoft.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.txt file in the root directory of this source tree.\n */\n\nconst {hasOwnProperty} = Object.prototype;\nconst cache$1 = new Map();\n// see https://github.com/pillarjs/path-to-regexp/issues/148\ncache$1.set('|false', {\n  keys: [],\n  pattern: /(?:)/\n});\n\nfunction decodeParam(val) {\n  try {\n    return decodeURIComponent(val);\n  } catch (err) {\n    return val;\n  }\n}\n\nfunction matchPath(routepath, path, exact, parentKeys, parentParams) {\n  exact = !!exact;\n  const cacheKey = `${routepath}|${exact}`;\n  let regexp = cache$1.get(cacheKey);\n\n  if (!regexp) {\n    const keys = [];\n    regexp = {\n      keys,\n      pattern: pathToRegexp_1(routepath, keys, {\n        end: exact,\n        strict: routepath === ''\n      }),\n    };\n    cache$1.set(cacheKey, regexp);\n  }\n\n  const m = regexp.pattern.exec(path);\n  if (!m) {\n    return null;\n  }\n\n  const params = Object.assign({}, parentParams);\n\n  for (let i = 1; i < m.length; i++) {\n    const key = regexp.keys[i - 1];\n    const prop = key.name;\n    const value = m[i];\n    if (value !== undefined || !hasOwnProperty.call(params, prop)) {\n      if (key.repeat) {\n        params[prop] = value ? value.split(key.delimiter).map(decodeParam) : [];\n      } else {\n        params[prop] = value ? decodeParam(value) : value;\n      }\n    }\n  }\n\n  return {\n    path: m[0],\n    keys: (parentKeys || []).concat(regexp.keys),\n    params,\n  };\n}\n\n/**\n * Universal Router (https://www.kriasoft.com/universal-router/)\n *\n * Copyright (c) 2015-present Kriasoft.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.txt file in the root directory of this source tree.\n */\n\n/**\n * Traverses the routes tree and matches its nodes to the given pathname from\n * the root down to the leaves. Each match consumes a part of the pathname and\n * the matching process continues for as long as there is a matching child\n * route for the remaining part of the pathname.\n *\n * The returned value is a lazily evaluated iterator.\n *\n * The leading \"/\" in a route path matters only for the root of the routes\n * tree (or if all parent routes are \"\"). In all other cases a leading \"/\" in\n * a child route path has no significance.\n *\n * The trailing \"/\" in a _route path_ matters only for the leaves of the\n * routes tree. A leaf route with a trailing \"/\" matches only a pathname that\n * also has a trailing \"/\".\n *\n * The trailing \"/\" in a route path does not affect matching of child routes\n * in any way.\n *\n * The trailing \"/\" in a _pathname_ generally does not matter (except for\n * the case of leaf nodes described above).\n *\n * The \"\" and \"/\" routes have special treatment:\n *  1. as a single route\n *     the \"\" and \"/\" routes match only the \"\" and \"/\" pathnames respectively\n *  2. as a parent in the routes tree\n *     the \"\" route matches any pathname without consuming any part of it\n *     the \"/\" route matches any absolute pathname consuming its leading \"/\"\n *  3. as a leaf in the routes tree\n *     the \"\" and \"/\" routes match only if the entire pathname is consumed by\n *         the parent routes chain. In this case \"\" and \"/\" are equivalent.\n *  4. several directly nested \"\" or \"/\" routes\n *     - directly nested \"\" or \"/\" routes are 'squashed' (i.e. nesting two\n *       \"/\" routes does not require a double \"/\" in the pathname to match)\n *     - if there are only \"\" in the parent routes chain, no part of the\n *       pathname is consumed, and the leading \"/\" in the child routes' paths\n *       remains significant\n *\n * Side effect:\n *   - the routes tree { path: '' } matches only the '' pathname\n *   - the routes tree { path: '', children: [ { path: '' } ] } matches any\n *     pathname (for the tree root)\n *\n * Prefix matching can be enabled also by `children: true`.\n */\nfunction matchRoute(route, pathname, ignoreLeadingSlash, parentKeys, parentParams) {\n  let match;\n  let childMatches;\n  let childIndex = 0;\n  let routepath = route.path || '';\n  if (routepath.charAt(0) === '/') {\n    if (ignoreLeadingSlash) {\n      routepath = routepath.substr(1);\n    }\n    ignoreLeadingSlash = true;\n  }\n\n  return {\n    next(routeToSkip) {\n      if (route === routeToSkip) {\n        return {done: true};\n      }\n\n      const children = route.__children = route.__children || route.children;\n\n      if (!match) {\n        match = matchPath(routepath, pathname, !children, parentKeys, parentParams);\n\n        if (match) {\n          return {\n            done: false,\n            value: {\n              route,\n              keys: match.keys,\n              params: match.params,\n              path: match.path\n            },\n          };\n        }\n      }\n\n      if (match && children) {\n        while (childIndex < children.length) {\n          if (!childMatches) {\n            const childRoute = children[childIndex];\n            childRoute.parent = route;\n\n            let matchedLength = match.path.length;\n            if (matchedLength > 0 && pathname.charAt(matchedLength) === '/') {\n              matchedLength += 1;\n            }\n\n            childMatches = matchRoute(\n              childRoute,\n              pathname.substr(matchedLength),\n              ignoreLeadingSlash,\n              match.keys,\n              match.params\n            );\n          }\n\n          const childMatch = childMatches.next(routeToSkip);\n          if (!childMatch.done) {\n            return {\n              done: false,\n              value: childMatch.value,\n            };\n          }\n\n          childMatches = null;\n          childIndex++;\n        }\n      }\n\n      return {done: true};\n    },\n  };\n}\n\n/**\n * Universal Router (https://www.kriasoft.com/universal-router/)\n *\n * Copyright (c) 2015-present Kriasoft.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.txt file in the root directory of this source tree.\n */\n\nfunction resolveRoute(context) {\n  if (isFunction(context.route.action)) {\n    return context.route.action(context);\n  }\n  return undefined;\n}\n\n/**\n * Universal Router (https://www.kriasoft.com/universal-router/)\n *\n * Copyright (c) 2015-present Kriasoft.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.txt file in the root directory of this source tree.\n */\n\nfunction isChildRoute(parentRoute, childRoute) {\n  let route = childRoute;\n  while (route) {\n    route = route.parent;\n    if (route === parentRoute) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction generateErrorMessage(currentContext) {\n  let errorMessage = `Path '${currentContext.pathname}' is not properly resolved due to an error.`;\n  const routePath = (currentContext.route || {}).path;\n  if (routePath) {\n    errorMessage += ` Resolution had failed on route: '${routePath}'`;\n  }\n  return errorMessage;\n}\n\nfunction updateChainForRoute(context, match) {\n  const {route, path} = match;\n\n  if (route && !route.__synthetic) {\n    const item = {path, route};\n    if (!context.chain) {\n      context.chain = [];\n    } else {\n      // Discard old items\n      if (route.parent) {\n        let i = context.chain.length;\n        while (i-- && context.chain[i].route && context.chain[i].route !== route.parent) {\n          context.chain.pop();\n        }\n      }\n    }\n    context.chain.push(item);\n  }\n}\n\n/**\n */\nclass Resolver {\n  constructor(routes, options = {}) {\n    if (Object(routes) !== routes) {\n      throw new TypeError('Invalid routes');\n    }\n\n    this.baseUrl = options.baseUrl || '';\n    this.errorHandler = options.errorHandler;\n    this.resolveRoute = options.resolveRoute || resolveRoute;\n    this.context = Object.assign({resolver: this}, options.context);\n    this.root = Array.isArray(routes) ? {path: '', __children: routes, parent: null, __synthetic: true} : routes;\n    this.root.parent = null;\n  }\n\n  /**\n   * Returns the current list of routes (as a shallow copy). Adding / removing\n   * routes to / from the returned array does not affect the routing config,\n   * but modifying the route objects does.\n   *\n   * @return {!Array<!Router.Route>}\n   */\n  getRoutes() {\n    return [...this.root.__children];\n  }\n\n  /**\n   * Sets the routing config (replacing the existing one).\n   *\n   * @param {!Array<!Router.Route>|!Router.Route} routes a single route or an array of those\n   *    (the array is shallow copied)\n   */\n  setRoutes(routes) {\n    ensureRoutes(routes);\n    const newRoutes = [...toArray(routes)];\n    this.root.__children = newRoutes;\n  }\n\n  /**\n   * Appends one or several routes to the routing config and returns the\n   * effective routing config after the operation.\n   *\n   * @param {!Array<!Router.Route>|!Router.Route} routes a single route or an array of those\n   *    (the array is shallow copied)\n   * @return {!Array<!Router.Route>}\n   * @protected\n   */\n  addRoutes(routes) {\n    ensureRoutes(routes);\n    this.root.__children.push(...toArray(routes));\n    return this.getRoutes();\n  }\n\n  /**\n   * Removes all existing routes from the routing config.\n   */\n  removeRoutes() {\n    this.setRoutes([]);\n  }\n\n  /**\n   * Asynchronously resolves the given pathname, i.e. finds all routes matching\n   * the pathname and tries resolving them one after another in the order they\n   * are listed in the routes config until the first non-null result.\n   *\n   * Returns a promise that is fulfilled with the return value of an object that consists of the first\n   * route handler result that returns something other than `null` or `undefined` and context used to get this result.\n   *\n   * If no route handlers return a non-null result, or if no route matches the\n   * given pathname the returned promise is rejected with a 'page not found'\n   * `Error`.\n   *\n   * @param {!string|!{pathname: !string}} pathnameOrContext the pathname to\n   *    resolve or a context object with a `pathname` property and other\n   *    properties to pass to the route resolver functions.\n   * @return {!Promise<any>}\n   */\n  resolve(pathnameOrContext) {\n    const context = Object.assign(\n      {},\n      this.context,\n      isString(pathnameOrContext) ? {pathname: pathnameOrContext} : pathnameOrContext\n    );\n    const match = matchRoute(\n      this.root,\n      this.__normalizePathname(context.pathname),\n      this.baseUrl\n    );\n    const resolve = this.resolveRoute;\n    let matches = null;\n    let nextMatches = null;\n    let currentContext = context;\n\n    function next(resume, parent = matches.value.route, prevResult) {\n      const routeToSkip = prevResult === null && matches.value.route;\n      matches = nextMatches || match.next(routeToSkip);\n      nextMatches = null;\n\n      if (!resume) {\n        if (matches.done || !isChildRoute(parent, matches.value.route)) {\n          nextMatches = matches;\n          return Promise.resolve(notFoundResult);\n        }\n      }\n\n      if (matches.done) {\n        return Promise.reject(getNotFoundError(context));\n      }\n\n      currentContext = Object.assign(\n        currentContext\n          ? {chain: (currentContext.chain ? currentContext.chain.slice(0) : [])}\n          : {},\n        context,\n        matches.value\n      );\n      updateChainForRoute(currentContext, matches.value);\n\n      return Promise.resolve(resolve(currentContext)).then(resolution => {\n        if (resolution !== null && resolution !== undefined && resolution !== notFoundResult) {\n          currentContext.result = resolution.result || resolution;\n          return currentContext;\n        }\n        return next(resume, parent, resolution);\n      });\n    }\n\n    context.next = next;\n\n    return Promise.resolve()\n      .then(() => next(true, this.root))\n      .catch((error) => {\n        const errorMessage = generateErrorMessage(currentContext);\n        if (!error) {\n          error = new Error(errorMessage);\n        } else {\n          console.warn(errorMessage);\n        }\n        error.context = error.context || currentContext;\n        // DOMException has its own code which is read-only\n        if (!(error instanceof DOMException)) {\n          error.code = error.code || 500;\n        }\n        if (this.errorHandler) {\n          currentContext.result = this.errorHandler(error);\n          return currentContext;\n        }\n        throw error;\n      });\n  }\n\n  /**\n   * URL constructor polyfill hook. Creates and returns an URL instance.\n   */\n  static __createUrl(url, base) {\n    return new URL(url, base);\n  }\n\n  /**\n   * If the baseUrl property is set, transforms the baseUrl and returns the full\n   * actual `base` string for using in the `new URL(path, base);` and for\n   * prepernding the paths with. The returned base ends with a trailing slash.\n   *\n   * Otherwise, returns empty string.\n   */\n  get __effectiveBaseUrl() {\n    return this.baseUrl\n      ? this.constructor.__createUrl(\n        this.baseUrl,\n        document.baseURI || document.URL\n      ).href.replace(/[^\\/]*$/, '')\n      : '';\n  }\n\n  /**\n   * If the baseUrl is set, matches the pathname with the router’s baseUrl,\n   * and returns the local pathname with the baseUrl stripped out.\n   *\n   * If the pathname does not match the baseUrl, returns undefined.\n   *\n   * If the `baseUrl` is not set, returns the unmodified pathname argument.\n   */\n  __normalizePathname(pathname) {\n    if (!this.baseUrl) {\n      // No base URL, no need to transform the pathname.\n      return pathname;\n    }\n\n    const base = this.__effectiveBaseUrl;\n    const normalizedUrl = this.constructor.__createUrl(pathname, base).href;\n    if (normalizedUrl.slice(0, base.length) === base) {\n      return normalizedUrl.slice(base.length);\n    }\n  }\n}\n\nResolver.pathToRegexp = pathToRegexp_1;\n\n/**\n * Universal Router (https://www.kriasoft.com/universal-router/)\n *\n * Copyright (c) 2015-present Kriasoft.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.txt file in the root directory of this source tree.\n */\n\nconst {pathToRegexp} = Resolver;\nconst cache = new Map();\n\nfunction cacheRoutes(routesByName, route, routes) {\n  const name = route.name || route.component;\n  if (name) {\n    if (routesByName.has(name)) {\n      routesByName.get(name).push(route);\n    } else {\n      routesByName.set(name, [route]);\n    }\n  }\n\n  if (Array.isArray(routes)) {\n    for (let i = 0; i < routes.length; i++) {\n      const childRoute = routes[i];\n      childRoute.parent = route;\n      cacheRoutes(routesByName, childRoute, childRoute.__children || childRoute.children);\n    }\n  }\n}\n\nfunction getRouteByName(routesByName, routeName) {\n  const routes = routesByName.get(routeName);\n  if (routes && routes.length > 1) {\n    throw new Error(\n      `Duplicate route with name \"${routeName}\".`\n      + ` Try seting unique 'name' route properties.`\n    );\n  }\n  return routes && routes[0];\n}\n\nfunction getRoutePath(route) {\n  let path = route.path;\n  path = Array.isArray(path) ? path[0] : path;\n  return path !== undefined ? path : '';\n}\n\nfunction generateUrls(router, options = {}) {\n  if (!(router instanceof Resolver)) {\n    throw new TypeError('An instance of Resolver is expected');\n  }\n\n  const routesByName = new Map();\n\n  return (routeName, params) => {\n    let route = getRouteByName(routesByName, routeName);\n    if (!route) {\n      routesByName.clear(); // clear cache\n      cacheRoutes(routesByName, router.root, router.root.__children);\n\n      route = getRouteByName(routesByName, routeName);\n      if (!route) {\n        throw new Error(`Route \"${routeName}\" not found`);\n      }\n    }\n\n    let regexp = cache.get(route.fullPath);\n    if (!regexp) {\n      let fullPath = getRoutePath(route);\n      let rt = route.parent;\n      while (rt) {\n        const path = getRoutePath(rt);\n        if (path) {\n          fullPath = path.replace(/\\/$/, '') + '/' + fullPath.replace(/^\\//, '');\n        }\n        rt = rt.parent;\n      }\n      const tokens = pathToRegexp.parse(fullPath);\n      const toPath = pathToRegexp.tokensToFunction(tokens);\n      const keys = Object.create(null);\n      for (let i = 0; i < tokens.length; i++) {\n        if (!isString(tokens[i])) {\n          keys[tokens[i].name] = true;\n        }\n      }\n      regexp = {toPath, keys};\n      cache.set(fullPath, regexp);\n      route.fullPath = fullPath;\n    }\n\n    let url = regexp.toPath(params, options) || '/';\n\n    if (options.stringifyQueryParams && params) {\n      const queryParams = {};\n      const keys = Object.keys(params);\n      for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        if (!regexp.keys[key]) {\n          queryParams[key] = params[key];\n        }\n      }\n      const query = options.stringifyQueryParams(queryParams);\n      if (query) {\n        url += query.charAt(0) === '?' ? query : `?${query}`;\n      }\n    }\n\n    return url;\n  };\n}\n\n/**\n * @typedef NavigationTrigger\n * @type {object}\n * @property {function()} activate\n * @property {function()} inactivate\n */\n\n/** @type {Array<NavigationTrigger>} */\nlet triggers = [];\n\nfunction setNavigationTriggers(newTriggers) {\n  triggers.forEach(trigger => trigger.inactivate());\n\n  newTriggers.forEach(trigger => trigger.activate());\n\n  triggers = newTriggers;\n}\n\nconst willAnimate = elem => {\n  const name = getComputedStyle(elem).getPropertyValue('animation-name');\n  return name && name !== 'none';\n};\n\nconst waitForAnimation = (elem, cb) => {\n  const listener = () => {\n    elem.removeEventListener('animationend', listener);\n    cb();\n  };\n  elem.addEventListener('animationend', listener);\n};\n\nfunction animate(elem, className) {\n  elem.classList.add(className);\n\n  return new Promise(resolve => {\n    if (willAnimate(elem)) {\n      const rect = elem.getBoundingClientRect();\n      const size = `height: ${rect.bottom - rect.top}px; width: ${rect.right - rect.left}px`;\n      elem.setAttribute('style', `position: absolute; ${size}`);\n      waitForAnimation(elem, () => {\n        elem.classList.remove(className);\n        elem.removeAttribute('style');\n        resolve();\n      });\n    } else {\n      elem.classList.remove(className);\n      resolve();\n    }\n  });\n}\n\nconst MAX_REDIRECT_COUNT = 256;\n\nfunction isResultNotEmpty(result) {\n  return result !== null && result !== undefined;\n}\n\nfunction copyContextWithoutNext(context) {\n  const copy = Object.assign({}, context);\n  delete copy.next;\n  return copy;\n}\n\nfunction createLocation({pathname = '', search = '', hash = '', chain = [], params = {}, redirectFrom, resolver}, route) {\n  const routes = chain.map(item => item.route);\n  return {\n    baseUrl: resolver && resolver.baseUrl || '',\n    pathname,\n    search,\n    hash,\n    routes,\n    route: route || routes.length && routes[routes.length - 1] || null,\n    params,\n    redirectFrom,\n    getUrl: (userParams = {}) => getPathnameForRouter(\n      Router.pathToRegexp.compile(\n        getMatchedPath(routes)\n      )(Object.assign({}, params, userParams)),\n      resolver\n    )\n  };\n}\n\nfunction createRedirect(context, pathname) {\n  const params = Object.assign({}, context.params);\n  return {\n    redirect: {\n      pathname,\n      from: context.pathname,\n      params\n    }\n  };\n}\n\nfunction renderElement(context, element) {\n  element.location = createLocation(context);\n  const index = context.chain.map(item => item.route).indexOf(context.route);\n  context.chain[index].element = element;\n  return element;\n}\n\nfunction runCallbackIfPossible(callback, args, thisArg) {\n  if (isFunction(callback)) {\n    return callback.apply(thisArg, args);\n  }\n}\n\nfunction amend(amendmentFunction, args, element) {\n  return amendmentResult => {\n    if (amendmentResult && (amendmentResult.cancel || amendmentResult.redirect)) {\n      return amendmentResult;\n    }\n\n    if (element) {\n      return runCallbackIfPossible(element[amendmentFunction], args, element);\n    }\n  };\n}\n\nfunction processNewChildren(newChildren, route) {\n  if (!Array.isArray(newChildren) && !isObject(newChildren)) {\n    throw new Error(\n      log(\n        `Incorrect \"children\" value for the route ${route.path}: expected array or object, but got ${newChildren}`\n      )\n    );\n  }\n\n  route.__children = [];\n  const childRoutes = toArray(newChildren);\n  for (let i = 0; i < childRoutes.length; i++) {\n    ensureRoute(childRoutes[i]);\n    route.__children.push(childRoutes[i]);\n  }\n}\n\nfunction removeDomNodes(nodes) {\n  if (nodes && nodes.length) {\n    const parent = nodes[0].parentNode;\n    for (let i = 0; i < nodes.length; i++) {\n      parent.removeChild(nodes[i]);\n    }\n  }\n}\n\nfunction getPathnameForRouter(pathname, router) {\n  const base = router.__effectiveBaseUrl;\n  return base\n    ? router.constructor.__createUrl(pathname.replace(/^\\//, ''), base).pathname\n    : pathname;\n}\n\nfunction getMatchedPath(chain) {\n  return chain.map(item => item.path).reduce((a, b) => {\n    if (b.length) {\n      return a.replace(/\\/$/, '') + '/' + b.replace(/^\\//, '');\n    }\n    return a;\n  }, '');\n}\n\n/**\n * A simple client-side router for single-page applications. It uses\n * express-style middleware and has a first-class support for Web Components and\n * lazy-loading. Works great in Polymer and non-Polymer apps.\n *\n * Use `new Router(outlet, options)` to create a new Router instance.\n *\n * * The `outlet` parameter is a reference to the DOM node to render\n *   the content into.\n *\n * * The `options` parameter is an optional object with options. The following\n *   keys are supported:\n *   * `baseUrl` — the initial value for [\n *     the `baseUrl` property\n *   ](#/classes/Router#property-baseUrl)\n *\n * The Router instance is automatically subscribed to navigation events\n * on `window`.\n *\n * See [Live Examples](#/classes/Router/demos/demo/index.html) for the detailed usage demo and code snippets.\n *\n * See also detailed API docs for the following methods, for the advanced usage:\n *\n * * [setOutlet](#/classes/Router#method-setOutlet) – should be used to configure the outlet.\n * * [setTriggers](#/classes/Router#method-setTriggers) – should be used to configure the navigation events.\n * * [setRoutes](#/classes/Router#method-setRoutes) – should be used to configure the routes.\n *\n * Only `setRoutes` has to be called manually, others are automatically invoked when creating a new instance.\n *\n * @extends Resolver\n * @demo demo/index.html\n * @summary JavaScript class that renders different DOM content depending on\n *    a given path. It can re-render when triggered or automatically on\n *    'popstate' and / or 'click' events.\n */\nclass Router extends Resolver {\n\n  /**\n   * Creates a new Router instance with a given outlet, and\n   * automatically subscribes it to navigation events on the `window`.\n   * Using a constructor argument or a setter for outlet is equivalent:\n   *\n   * ```\n   * const router = new Router();\n   * router.setOutlet(outlet);\n   * ```\n   * @param {?Node=} outlet\n   * @param {?RouterOptions=} options\n   */\n  constructor(outlet, options) {\n    const baseElement = document.head.querySelector('base');\n    const baseHref = baseElement && baseElement.getAttribute('href');\n    super([], Object.assign({\n      // Default options\n      baseUrl: baseHref && Resolver.__createUrl(baseHref, document.URL).pathname.replace(/[^\\/]*$/, '')\n    }, options));\n\n    this.resolveRoute = context => this.__resolveRoute(context);\n\n    const triggers = Router.NavigationTrigger;\n    Router.setTriggers.apply(Router, Object.keys(triggers).map(key => triggers[key]));\n\n    /**\n     * The base URL for all routes in the router instance. By default,\n     * if the base element exists in the `<head>`, vaadin-router\n     * takes the `<base href>` attribute value, resolves against current `document.URL`\n     * and gets the `pathname` from the result.\n     *\n     * @public\n     * @type {string}\n     */\n    this.baseUrl;\n\n    /**\n     * A promise that is settled after the current render cycle completes. If\n     * there is no render cycle in progress the promise is immediately settled\n     * with the last render cycle result.\n     *\n     * @public\n     * @type {!Promise<!RouterLocation>}\n     */\n    this.ready;\n    this.ready = Promise.resolve(outlet);\n\n    /**\n     * Contains read-only information about the current router location:\n     * pathname, active routes, parameters. See the\n     * [Location type declaration](#/classes/RouterLocation)\n     * for more details.\n     *\n     * @public\n     * @type {!RouterLocation}\n     */\n    this.location;\n    this.location = createLocation({resolver: this});\n\n    this.__lastStartedRenderId = 0;\n    this.__navigationEventHandler = this.__onNavigationEvent.bind(this);\n    this.setOutlet(outlet);\n    this.subscribe();\n    // Using WeakMap instead of WeakSet because WeakSet is not supported by IE11\n    this.__createdByRouter = new WeakMap();\n    this.__addedByRouter = new WeakMap();\n  }\n\n  __resolveRoute(context) {\n    const route = context.route;\n\n    let callbacks = Promise.resolve();\n\n    if (isFunction(route.children)) {\n      callbacks = callbacks\n        .then(() => route.children(copyContextWithoutNext(context)))\n        .then(children => {\n          // The route.children() callback might have re-written the\n          // route.children property instead of returning a value\n          if (!isResultNotEmpty(children) && !isFunction(route.children)) {\n            children = route.children;\n          }\n          processNewChildren(children, route);\n        });\n    }\n\n    const commands = {\n      redirect: path => createRedirect(context, path),\n      component: (component) => {\n        const element = document.createElement(component);\n        this.__createdByRouter.set(element, true);\n        return element;\n      }\n    };\n\n    return callbacks\n      .then(() => {\n        if (this.__isLatestRender(context)) {\n          return runCallbackIfPossible(route.action, [context, commands], route);\n        }\n      })\n      .then(result => {\n        if (isResultNotEmpty(result)) {\n          // Actions like `() => import('my-view.js')` are not expected to\n          // end the resolution, despite the result is not empty. Checking\n          // the result with a whitelist of values that end the resolution.\n          if (result instanceof HTMLElement ||\n              result.redirect ||\n              result === notFoundResult) {\n            return result;\n          }\n        }\n\n        if (isString(route.redirect)) {\n          return commands.redirect(route.redirect);\n        }\n\n        if (route.bundle) {\n          return loadBundle(route.bundle)\n            .then(() => {}, () => {\n              throw new Error(log(`Bundle not found: ${route.bundle}. Check if the file name is correct`));\n            });\n        }\n      })\n      .then(result => {\n        if (isResultNotEmpty(result)) {\n          return result;\n        }\n        if (isString(route.component)) {\n          return commands.component(route.component);\n        }\n      });\n  }\n\n  /**\n   * Sets the router outlet (the DOM node where the content for the current\n   * route is inserted). Any content pre-existing in the router outlet is\n   * removed at the end of each render pass.\n   *\n   * NOTE: this method is automatically invoked first time when creating a new Router instance.\n   *\n   * @param {?Node} outlet the DOM node where the content for the current route\n   *     is inserted.\n   */\n  setOutlet(outlet) {\n    if (outlet) {\n      this.__ensureOutlet(outlet);\n    }\n    this.__outlet = outlet;\n  }\n\n  /**\n   * Returns the current router outlet. The initial value is `undefined`.\n   *\n   * @return {?Node} the current router outlet (or `undefined`)\n   */\n  getOutlet() {\n    return this.__outlet;\n  }\n\n  /**\n   * Sets the routing config (replacing the existing one) and triggers a\n   * navigation event so that the router outlet is refreshed according to the\n   * current `window.location` and the new routing config.\n   *\n   * Each route object may have the following properties, listed here in the processing order:\n   * * `path` – the route path (relative to the parent route if any) in the\n   * [express.js syntax](https://expressjs.com/en/guide/routing.html#route-paths\").\n   *\n   * * `children` – an array of nested routes or a function that provides this\n   * array at the render time. The function can be synchronous or asynchronous:\n   * in the latter case the render is delayed until the returned promise is\n   * resolved. The `children` function is executed every time when this route is\n   * being rendered. This allows for dynamic route structures (e.g. backend-defined),\n   * but it might have a performance impact as well. In order to avoid calling\n   * the function on subsequent renders, you can override the `children` property\n   * of the route object and save the calculated array there\n   * (via `context.route.children = [ route1, route2, ...];`).\n   * Parent routes are fully resolved before resolving the children. Children\n   * 'path' values are relative to the parent ones.\n   *\n   * * `action` – the action that is executed before the route is resolved.\n   * The value for this property should be a function, accepting `context`\n   * and `commands` parameters described below. If present, this function is\n   * always invoked first, disregarding of the other properties' presence.\n   * The action can return a result directly or within a `Promise`, which\n   * resolves to the result. If the action result is an `HTMLElement` instance,\n   * a `commands.component(name)` result, a `commands.redirect(path)` result,\n   * or a `context.next()` result, the current route resolution is finished,\n   * and other route config properties are ignored.\n   * See also **Route Actions** section in [Live Examples](#/classes/Router/demos/demo/index.html).\n   *\n   * * `redirect` – other route's path to redirect to. Passes all route parameters to the redirect target.\n   * The target route should also be defined.\n   * See also **Redirects** section in [Live Examples](#/classes/Router/demos/demo/index.html).\n   *\n   * * `bundle` – string containing the path to `.js` or `.mjs` bundle to load before resolving the route,\n   * or the object with \"module\" and \"nomodule\" keys referring to different bundles.\n   * Each bundle is only loaded once. If \"module\" and \"nomodule\" are set, only one bundle is loaded,\n   * depending on whether the browser supports ES modules or not.\n   * The property is ignored when either an `action` returns the result or `redirect` property is present.\n   * Any error, e.g. 404 while loading bundle will cause route resolution to throw.\n   * See also **Code Splitting** section in [Live Examples](#/classes/Router/demos/demo/index.html).\n   *\n   * * `component` – the tag name of the Web Component to resolve the route to.\n   * The property is ignored when either an `action` returns the result or `redirect` property is present.\n   * If route contains the `component` property (or an action that return a component)\n   * and its child route also contains the `component` property, child route's component\n   * will be rendered as a light dom child of a parent component.\n   *\n   * * `name` – the string name of the route to use in the\n   * [`router.urlForName(name, params)`](#/classes/Router#method-urlForName)\n   * navigation helper method.\n   *\n   * For any route function (`action`, `children`) defined, the corresponding `route` object is available inside the callback\n   * through the `this` reference. If you need to access it, make sure you define the callback as a non-arrow function\n   * because arrow functions do not have their own `this` reference.\n   *\n   * `context` object that is passed to `action` function holds the following properties:\n   * * `context.pathname` – string with the pathname being resolved\n   *\n   * * `context.search` – search query string\n   *\n   * * `context.hash` – hash string\n   *\n   * * `context.params` – object with route parameters\n   *\n   * * `context.route` – object that holds the route that is currently being rendered.\n   *\n   * * `context.next()` – function for asynchronously getting the next route\n   * contents from the resolution chain (if any)\n   *\n   * `commands` object that is passed to `action` function has\n   * the following methods:\n   *\n   * * `commands.redirect(path)` – function that creates a redirect data\n   * for the path specified.\n   *\n   * * `commands.component(component)` – function that creates a new HTMLElement\n   * with current context. Note: the component created by this function is reused if visiting the same path twice in row.\n   *\n   *\n   * @param {!Array<!Route>|!Route} routes a single route or an array of those\n   * @param {?boolean} skipRender configure the router but skip rendering the\n   *     route corresponding to the current `window.location` values\n   *\n   * @return {!Promise<!Node>}\n   */\n  setRoutes(routes, skipRender = false) {\n    this.__previousContext = undefined;\n    this.__urlForName = undefined;\n    super.setRoutes(routes);\n    if (!skipRender) {\n      this.__onNavigationEvent();\n    }\n    return this.ready;\n  }\n\n  /**\n   * Asynchronously resolves the given pathname and renders the resolved route\n   * component into the router outlet. If no router outlet is set at the time of\n   * calling this method, or at the time when the route resolution is completed,\n   * a `TypeError` is thrown.\n   *\n   * Returns a promise that is fulfilled with the router outlet DOM Node after\n   * the route component is created and inserted into the router outlet, or\n   * rejected if no route matches the given path.\n   *\n   * If another render pass is started before the previous one is completed, the\n   * result of the previous render pass is ignored.\n   *\n   * @param {!string|!{pathname: !string, search: ?string, hash: ?string}} pathnameOrContext\n   *    the pathname to render or a context object with a `pathname` property,\n   *    optional `search` and `hash` properties, and other properties\n   *    to pass to the resolver.\n   * @param {boolean=} shouldUpdateHistory\n   *    update browser history with the rendered location\n   * @return {!Promise<!Node>}\n   */\n  render(pathnameOrContext, shouldUpdateHistory) {\n    const renderId = ++this.__lastStartedRenderId;\n    const context = Object.assign(\n      {\n        search: '',\n        hash: ''\n      },\n      isString(pathnameOrContext)\n        ? {pathname: pathnameOrContext}\n        : pathnameOrContext,\n      {\n        __renderId: renderId\n      }\n    );\n\n    // Find the first route that resolves to a non-empty result\n    this.ready = this.resolve(context)\n\n      // Process the result of this.resolve() and handle all special commands:\n      // (redirect / prevent / component). If the result is a 'component',\n      // then go deeper and build the entire chain of nested components matching\n      // the pathname. Also call all 'on before' callbacks along the way.\n      .then(context => this.__fullyResolveChain(context))\n\n      .then(context => {\n        if (this.__isLatestRender(context)) {\n          const previousContext = this.__previousContext;\n\n          // Check if the render was prevented and make an early return in that case\n          if (context === previousContext) {\n            // Replace the history with the previous context\n            // to make sure the URL stays the same.\n            this.__updateBrowserHistory(previousContext, true);\n            return this.location;\n          }\n\n          this.location = createLocation(context);\n\n          if (shouldUpdateHistory) {\n            // Replace only if first render redirects, so that we don’t leave\n            // the redirecting record in the history\n            this.__updateBrowserHistory(context, renderId === 1);\n          }\n\n          fireRouterEvent('location-changed', {router: this, location: this.location});\n\n          // Skip detaching/re-attaching there are no render changes\n          if (context.__skipAttach) {\n            this.__copyUnchangedElements(context, previousContext);\n            this.__previousContext = context;\n            return this.location;\n          }\n\n          this.__addAppearingContent(context, previousContext);\n          const animationDone = this.__animateIfNeeded(context);\n\n          this.__runOnAfterEnterCallbacks(context);\n          this.__runOnAfterLeaveCallbacks(context, previousContext);\n\n          return animationDone.then(() => {\n            if (this.__isLatestRender(context)) {\n              // If there is another render pass started after this one,\n              // the 'disappearing content' would be removed when the other\n              // render pass calls `this.__addAppearingContent()`\n              this.__removeDisappearingContent();\n\n              this.__previousContext = context;\n              return this.location;\n            }\n          });\n        }\n      })\n      .catch(error => {\n        if (renderId === this.__lastStartedRenderId) {\n          if (shouldUpdateHistory) {\n            this.__updateBrowserHistory(context);\n          }\n          removeDomNodes(this.__outlet && this.__outlet.children);\n          this.location = createLocation(Object.assign(context, {resolver: this}));\n          fireRouterEvent('error', Object.assign({router: this, error}, context));\n          throw error;\n        }\n      });\n    return this.ready;\n  }\n\n  // `topOfTheChainContextBeforeRedirects` is a context coming from Resolver.resolve().\n  // It would contain a 'redirect' route or the first 'component' route that\n  // matched the pathname. There might be more child 'component' routes to be\n  // resolved and added into the chain. This method would find and add them.\n  // `contextBeforeRedirects` is the context containing such a child component\n  // route. It's only necessary when this method is called recursively (otherwise\n  // it's the same as the 'top of the chain' context).\n  //\n  // Apart from building the chain of child components, this method would also\n  // handle 'redirect' routes, call 'onBefore' callbacks and handle 'prevent'\n  // and 'redirect' callback results.\n  __fullyResolveChain(topOfTheChainContextBeforeRedirects,\n    contextBeforeRedirects = topOfTheChainContextBeforeRedirects) {\n    return this.__findComponentContextAfterAllRedirects(contextBeforeRedirects)\n      // `contextAfterRedirects` is always a context with an `HTMLElement` result\n      // In other cases the promise gets rejected and .then() is not called\n      .then(contextAfterRedirects => {\n        const redirectsHappened = contextAfterRedirects !== contextBeforeRedirects;\n        const topOfTheChainContextAfterRedirects =\n          redirectsHappened ? contextAfterRedirects : topOfTheChainContextBeforeRedirects;\n\n        const matchedPath = getPathnameForRouter(\n          getMatchedPath(contextAfterRedirects.chain),\n          contextAfterRedirects.resolver\n        );\n        const isFound = (matchedPath === contextAfterRedirects.pathname);\n\n        // Recursive method to try matching more child and sibling routes\n        const findNextContextIfAny = (context, parent = context.route, prevResult) => {\n          return context.next(undefined, parent, prevResult).then(nextContext => {\n            if (nextContext === null || nextContext === notFoundResult) {\n              // Next context is not found in children, ...\n              if (isFound) {\n                // ...but original context is already fully matching - use it\n                return context;\n              } else if (parent.parent !== null) {\n                // ...and there is no full match yet - step up to check siblings\n                return findNextContextIfAny(context, parent.parent, nextContext);\n              } else {\n                return nextContext;\n              }\n            }\n\n            return nextContext;\n          });\n        };\n\n        return findNextContextIfAny(contextAfterRedirects).then(nextContext => {\n          if (nextContext === null || nextContext === notFoundResult) {\n            throw getNotFoundError(topOfTheChainContextAfterRedirects);\n          }\n\n          return nextContext\n          && nextContext !== notFoundResult\n          && nextContext !== contextAfterRedirects\n            ? this.__fullyResolveChain(topOfTheChainContextAfterRedirects, nextContext)\n            : this.__amendWithOnBeforeCallbacks(contextAfterRedirects);\n        });\n      });\n  }\n\n  __findComponentContextAfterAllRedirects(context) {\n    const result = context.result;\n    if (result instanceof HTMLElement) {\n      renderElement(context, result);\n      return Promise.resolve(context);\n    } else if (result.redirect) {\n      return this.__redirect(result.redirect, context.__redirectCount, context.__renderId)\n        .then(context => this.__findComponentContextAfterAllRedirects(context));\n    } else if (result instanceof Error) {\n      return Promise.reject(result);\n    } else {\n      return Promise.reject(\n        new Error(\n          log(\n            `Invalid route resolution result for path \"${context.pathname}\". ` +\n            `Expected redirect object or HTML element, but got: \"${logValue(result)}\". ` +\n            `Double check the action return value for the route.`\n          )\n        ));\n    }\n  }\n\n  __amendWithOnBeforeCallbacks(contextWithFullChain) {\n    return this.__runOnBeforeCallbacks(contextWithFullChain).then(amendedContext => {\n      if (amendedContext === this.__previousContext || amendedContext === contextWithFullChain) {\n        return amendedContext;\n      }\n      return this.__fullyResolveChain(amendedContext);\n    });\n  }\n\n  __runOnBeforeCallbacks(newContext) {\n    const previousContext = this.__previousContext || {};\n    const previousChain = previousContext.chain || [];\n    const newChain = newContext.chain;\n\n    let callbacks = Promise.resolve();\n    const prevent = () => ({cancel: true});\n    const redirect = (pathname) => createRedirect(newContext, pathname);\n\n    newContext.__divergedChainIndex = 0;\n    newContext.__skipAttach = false;\n    if (previousChain.length) {\n      for (let i = 0; i < Math.min(previousChain.length, newChain.length); i = ++newContext.__divergedChainIndex) {\n        if (previousChain[i].route !== newChain[i].route\n          || previousChain[i].path !== newChain[i].path && previousChain[i].element !== newChain[i].element\n          || !this.__isReusableElement(previousChain[i].element, newChain[i].element)) {\n          break;\n        }\n      }\n\n      // Skip re-attaching and notifications if element and chain do not change\n      newContext.__skipAttach =\n        // Same route chain\n        newChain.length === previousChain.length && newContext.__divergedChainIndex == newChain.length &&\n        // Same element\n        this.__isReusableElement(newContext.result, previousContext.result);\n\n      if (newContext.__skipAttach) {\n        // execute onBeforeLeave for changed segment element when skipping attach\n        for (let i = newChain.length - 1; i >= 0; i--) {\n          callbacks = this.__runOnBeforeLeaveCallbacks(callbacks, newContext, {prevent}, previousChain[i]);\n        }\n        // execute onBeforeEnter for changed segment element when skipping attach\n        for (let i = 0; i < newChain.length; i++) {\n          callbacks = this.__runOnBeforeEnterCallbacks(callbacks, newContext, {prevent, redirect}, newChain[i]);\n          previousChain[i].element.location = createLocation(newContext, previousChain[i].route);\n        }\n\n      } else {\n        // execute onBeforeLeave when NOT skipping attach\n        for (let i = previousChain.length - 1; i >= newContext.__divergedChainIndex; i--) {\n          callbacks = this.__runOnBeforeLeaveCallbacks(callbacks, newContext, {prevent}, previousChain[i]);\n        }\n      }\n    }\n    // execute onBeforeEnter when NOT skipping attach\n    if (!newContext.__skipAttach) {\n      for (let i = 0; i < newChain.length; i++) {\n        if (i < newContext.__divergedChainIndex) {\n          if (i < previousChain.length && previousChain[i].element) {\n            previousChain[i].element.location = createLocation(newContext, previousChain[i].route);\n          }\n        } else {\n          callbacks = this.__runOnBeforeEnterCallbacks(callbacks, newContext, {prevent, redirect}, newChain[i]);\n          if (newChain[i].element) {\n            newChain[i].element.location = createLocation(newContext, newChain[i].route);\n          }\n        }\n      }\n    }\n    return callbacks.then(amendmentResult => {\n      if (amendmentResult) {\n        if (amendmentResult.cancel) {\n          this.__previousContext.__renderId = newContext.__renderId;\n          return this.__previousContext;\n        }\n        if (amendmentResult.redirect) {\n          return this.__redirect(amendmentResult.redirect, newContext.__redirectCount, newContext.__renderId);\n        }\n      }\n      return newContext;\n    });\n  }\n\n  __runOnBeforeLeaveCallbacks(callbacks, newContext, commands, chainElement) {\n    const location = createLocation(newContext);\n    return callbacks.then(result => {\n      if (this.__isLatestRender(newContext)) {\n        const afterLeaveFunction = amend('onBeforeLeave', [location, commands, this], chainElement.element);\n        return afterLeaveFunction(result);\n      }\n    }).then(result => {\n      if (!(result || {}).redirect) {\n        return result;\n      }\n    });\n  }\n\n  __runOnBeforeEnterCallbacks(callbacks, newContext, commands, chainElement) {\n    const location = createLocation(newContext, chainElement.route);\n    return callbacks.then(result => {\n      if (this.__isLatestRender(newContext)) {\n        const beforeEnterFunction = amend('onBeforeEnter', [location, commands, this], chainElement.element);\n        return beforeEnterFunction(result);\n      }\n    });\n  }\n\n  __isReusableElement(element, otherElement) {\n    if (element && otherElement) {\n      return this.__createdByRouter.get(element) && this.__createdByRouter.get(otherElement)\n        ? element.localName === otherElement.localName\n        : element === otherElement;\n    }\n    return false;\n  }\n\n  __isLatestRender(context) {\n    return context.__renderId === this.__lastStartedRenderId;\n  }\n\n  __redirect(redirectData, counter, renderId) {\n    if (counter > MAX_REDIRECT_COUNT) {\n      throw new Error(log(`Too many redirects when rendering ${redirectData.from}`));\n    }\n\n    return this.resolve({\n      pathname: this.urlForPath(\n        redirectData.pathname,\n        redirectData.params\n      ),\n      redirectFrom: redirectData.from,\n      __redirectCount: (counter || 0) + 1,\n      __renderId: renderId\n    });\n  }\n\n  __ensureOutlet(outlet = this.__outlet) {\n    if (!(outlet instanceof Node)) {\n      throw new TypeError(log(`Expected router outlet to be a valid DOM Node (but got ${outlet})`));\n    }\n  }\n\n  __updateBrowserHistory({pathname, search = '', hash = ''}, replace) {\n    if (window.location.pathname !== pathname\n        || window.location.search !== search\n        || window.location.hash !== hash\n    ) {\n      const changeState = replace ? 'replaceState' : 'pushState';\n      window.history[changeState](null, document.title, pathname + search + hash);\n      window.dispatchEvent(new PopStateEvent('popstate', {state: 'vaadin-router-ignore'}));\n    }\n  }\n\n  __copyUnchangedElements(context, previousContext) {\n    // Find the deepest common parent between the last and the new component\n    // chains. Update references for the unchanged elements in the new chain\n    let deepestCommonParent = this.__outlet;\n    for (let i = 0; i < context.__divergedChainIndex; i++) {\n      const unchangedElement = previousContext && previousContext.chain[i].element;\n      if (unchangedElement) {\n        if (unchangedElement.parentNode === deepestCommonParent) {\n          context.chain[i].element = unchangedElement;\n          deepestCommonParent = unchangedElement;\n        } else {\n          break;\n        }\n      }\n    }\n    return deepestCommonParent;\n  }\n\n  __addAppearingContent(context, previousContext) {\n    this.__ensureOutlet();\n\n    // If the previous 'entering' animation has not completed yet,\n    // stop it and remove that content from the DOM before adding new one.\n    this.__removeAppearingContent();\n\n    // Copy reusable elements from the previousContext to current\n    const deepestCommonParent = this.__copyUnchangedElements(context, previousContext);\n\n    // Keep two lists of DOM elements:\n    //  - those that should be removed once the transition animation is over\n    //  - and those that should remain\n    this.__appearingContent = [];\n    this.__disappearingContent = Array\n      .from(deepestCommonParent.children)\n      .filter(\n        // Only remove layout content that was added by router\n        e => this.__addedByRouter.get(e) &&\n        // Do not remove the result element to avoid flickering\n        e !== context.result);\n\n    // Add new elements (starting after the deepest common parent) to the DOM.\n    // That way only the components that are actually different between the two\n    // locations are added to the DOM (and those that are common remain in the\n    // DOM without first removing and then adding them again).\n    let parentElement = deepestCommonParent;\n    for (let i = context.__divergedChainIndex; i < context.chain.length; i++) {\n      const elementToAdd = context.chain[i].element;\n      if (elementToAdd) {\n        parentElement.appendChild(elementToAdd);\n        this.__addedByRouter.set(elementToAdd, true);\n        if (parentElement === deepestCommonParent) {\n          this.__appearingContent.push(elementToAdd);\n        }\n        parentElement = elementToAdd;\n      }\n    }\n  }\n\n  __removeDisappearingContent() {\n    if (this.__disappearingContent) {\n      removeDomNodes(this.__disappearingContent);\n    }\n    this.__disappearingContent = null;\n    this.__appearingContent = null;\n  }\n\n  __removeAppearingContent() {\n    if (this.__disappearingContent && this.__appearingContent) {\n      removeDomNodes(this.__appearingContent);\n      this.__disappearingContent = null;\n      this.__appearingContent = null;\n    }\n  }\n\n  __runOnAfterLeaveCallbacks(currentContext, targetContext) {\n    if (!targetContext) {\n      return;\n    }\n\n    // REVERSE iteration: from Z to A\n    for (let i = targetContext.chain.length - 1; i >= currentContext.__divergedChainIndex; i--) {\n      if (!this.__isLatestRender(currentContext)) {\n        break;\n      }\n      const currentComponent = targetContext.chain[i].element;\n      if (!currentComponent) {\n        continue;\n      }\n      try {\n        const location = createLocation(currentContext);\n        runCallbackIfPossible(\n          currentComponent.onAfterLeave,\n          [location, {}, targetContext.resolver],\n          currentComponent);\n      } finally {\n        if (this.__disappearingContent.indexOf(currentComponent) > -1) {\n          removeDomNodes(currentComponent.children);\n        }\n      }\n    }\n  }\n\n  __runOnAfterEnterCallbacks(currentContext) {\n    // forward iteration: from A to Z\n    for (let i = currentContext.__divergedChainIndex; i < currentContext.chain.length; i++) {\n      if (!this.__isLatestRender(currentContext)) {\n        break;\n      }\n      const currentComponent = currentContext.chain[i].element || {};\n      const location = createLocation(currentContext, currentContext.chain[i].route);\n      runCallbackIfPossible(\n        currentComponent.onAfterEnter,\n        [location, {}, currentContext.resolver],\n        currentComponent);\n    }\n  }\n\n  __animateIfNeeded(context) {\n    const from = (this.__disappearingContent || [])[0];\n    const to = (this.__appearingContent || [])[0];\n    const promises = [];\n\n    const chain = context.chain;\n    let config;\n    for (let i = chain.length; i > 0; i--) {\n      if (chain[i - 1].route.animate) {\n        config = chain[i - 1].route.animate;\n        break;\n      }\n    }\n\n    if (from && to && config) {\n      const leave = isObject(config) && config.leave || 'leaving';\n      const enter = isObject(config) && config.enter || 'entering';\n      promises.push(animate(from, leave));\n      promises.push(animate(to, enter));\n    }\n\n    return Promise.all(promises).then(() => context);\n  }\n\n  /**\n   * Subscribes this instance to navigation events on the `window`.\n   *\n   * NOTE: beware of resource leaks. For as long as a router instance is\n   * subscribed to navigation events, it won't be garbage collected.\n   */\n  subscribe() {\n    window.addEventListener('vaadin-router-go', this.__navigationEventHandler);\n  }\n\n  /**\n   * Removes the subscription to navigation events created in the `subscribe()`\n   * method.\n   */\n  unsubscribe() {\n    window.removeEventListener('vaadin-router-go', this.__navigationEventHandler);\n  }\n\n  __onNavigationEvent(event) {\n    const {pathname, search, hash} = event ? event.detail : window.location;\n    if (isString(this.__normalizePathname(pathname))) {\n      if (event && event.preventDefault) {\n        event.preventDefault();\n      }\n      this.render({pathname, search, hash}, true);\n    }\n  }\n\n  /**\n   * Configures what triggers Router navigation events:\n   *  - `POPSTATE`: popstate events on the current `window`\n   *  - `CLICK`: click events on `<a>` links leading to the current page\n   *\n   * This method is invoked with the pre-configured values when creating a new Router instance.\n   * By default, both `POPSTATE` and `CLICK` are enabled. This setup is expected to cover most of the use cases.\n   *\n   * See the `router-config.js` for the default navigation triggers config. Based on it, you can\n   * create the own one and only import the triggers you need, instead of pulling in all the code,\n   * e.g. if you want to handle `click` differently.\n   *\n   * See also **Navigation Triggers** section in [Live Examples](#/classes/Router/demos/demo/index.html).\n   *\n   * @param {...NavigationTrigger} triggers\n   */\n  static setTriggers(...triggers) {\n    setNavigationTriggers(triggers);\n  }\n\n  /**\n   * Generates a URL for the route with the given name, optionally performing\n   * substitution of parameters.\n   *\n   * The route is searched in all the Router instances subscribed to\n   * navigation events.\n   *\n   * **Note:** For child route names, only array children are considered.\n   * It is not possible to generate URLs using a name for routes set with\n   * a children function.\n   *\n   * @function urlForName\n   * @param {!string} name the route name or the route’s `component` name.\n   * @param {Params=} params Optional object with route path parameters.\n   * Named parameters are passed by name (`params[name] = value`), unnamed\n   * parameters are passed by index (`params[index] = value`).\n   *\n   * @return {string}\n   */\n  urlForName(name, params) {\n    if (!this.__urlForName) {\n      this.__urlForName = generateUrls(this);\n    }\n    return getPathnameForRouter(\n      this.__urlForName(name, params),\n      this\n    );\n  }\n\n  /**\n   * Generates a URL for the given route path, optionally performing\n   * substitution of parameters.\n   *\n   * @param {!string} path string route path declared in [express.js syntax](https://expressjs.com/en/guide/routing.html#route-paths\").\n   * @param {Params=} params Optional object with route path parameters.\n   * Named parameters are passed by name (`params[name] = value`), unnamed\n   * parameters are passed by index (`params[index] = value`).\n   *\n   * @return {string}\n   */\n  urlForPath(path, params) {\n    return getPathnameForRouter(\n      Router.pathToRegexp.compile(path)(params),\n      this\n    );\n  }\n\n  /**\n   * Triggers navigation to a new path. Returns a boolean without waiting until\n   * the navigation is complete. Returns `true` if at least one `Router`\n   * has handled the navigation (was subscribed and had `baseUrl` matching\n   * the `path` argument), otherwise returns `false`.\n   *\n   * @param {!string|!{pathname: !string, search: (string|undefined), hash: (string|undefined)}} path\n   *   a new in-app path string, or an URL-like object with `pathname`\n   *   string property, and optional `search` and `hash` string properties.\n   * @return {boolean}\n   */\n  static go(path) {\n    const {pathname, search, hash} = isString(path)\n      ? this.__createUrl(path, 'http://a') // some base to omit origin\n      : path;\n    return fireRouterEvent('go', {pathname, search, hash});\n  }\n}\n\nconst DEV_MODE_CODE_REGEXP =\n  /\\/\\*[\\*!]\\s+vaadin-dev-mode:start([\\s\\S]*)vaadin-dev-mode:end\\s+\\*\\*\\//i;\n\nconst FlowClients = window.Vaadin && window.Vaadin.Flow && window.Vaadin.Flow.clients;\n\nfunction isMinified() {\n  function test() {\n    /** vaadin-dev-mode:start\n    return false;\n    vaadin-dev-mode:end **/\n    return true;\n  }\n  return uncommentAndRun(test);\n}\n\nfunction isDevelopmentMode() {\n  try {\n    if (isForcedDevelopmentMode()) {\n      return true;\n    }\n\n    if (!isLocalhost()) {\n      return false;\n    }\n\n    if (FlowClients) {\n      return !isFlowProductionMode();\n    }\n\n    return !isMinified();\n  } catch (e) {\n    // Some error in this code, assume production so no further actions will be taken\n    return false;\n  }\n}\n\nfunction isForcedDevelopmentMode() {\n  return localStorage.getItem(\"vaadin.developmentmode.force\");\n}\n\nfunction isLocalhost() {\n  return ([\"localhost\",\"127.0.0.1\"].indexOf(window.location.hostname) >= 0);\n}\n\nfunction isFlowProductionMode() {\n  if (FlowClients) {\n    const productionModeApps = Object.keys(FlowClients)\n      .map(key => FlowClients[key])\n      .filter(client => client.productionMode);\n    if (productionModeApps.length > 0) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction uncommentAndRun(callback, args) {\n  if (typeof callback !== 'function') {\n    return;\n  }\n\n  const match = DEV_MODE_CODE_REGEXP.exec(callback.toString());\n  if (match) {\n    try {\n      // requires CSP: script-src 'unsafe-eval'\n      callback = new Function(match[1]);\n    } catch (e) {\n      // eat the exception\n      console.log('vaadin-development-mode-detector: uncommentAndRun() failed', e);\n    }\n  }\n\n  return callback(args);\n}\n\n// A guard against polymer-modulizer removing the window.Vaadin\n// initialization above.\nwindow['Vaadin'] = window['Vaadin'] || {};\n\n/**\n * Inspects the source code of the given `callback` function for\n * specially-marked _commented_ code. If such commented code is found in the\n * callback source, uncomments and runs that code instead of the callback\n * itself. Otherwise runs the callback as is.\n *\n * The optional arguments are passed into the callback / uncommented code,\n * the result is returned.\n *\n * See the `isMinified()` function source code in this file for an example.\n *\n */\nconst runIfDevelopmentMode = function(callback, args) {\n  if (window.Vaadin.developmentMode) {\n    return uncommentAndRun(callback, args);\n  }\n};\n\nif (window.Vaadin.developmentMode === undefined) {\n  window.Vaadin.developmentMode = isDevelopmentMode();\n}\n\n/* This file is autogenerated from src/vaadin-usage-statistics.tpl.html */\n\nfunction maybeGatherAndSendStats() {\n  /** vaadin-dev-mode:start\n  (function () {\n'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar getPolymerVersion = function getPolymerVersion() {\n  return window.Polymer && window.Polymer.version;\n};\n\nvar StatisticsGatherer = function () {\n  function StatisticsGatherer(logger) {\n    classCallCheck(this, StatisticsGatherer);\n\n    this.now = new Date().getTime();\n    this.logger = logger;\n  }\n\n  createClass(StatisticsGatherer, [{\n    key: 'frameworkVersionDetectors',\n    value: function frameworkVersionDetectors() {\n      return {\n        'Flow': function Flow() {\n          if (window.Vaadin && window.Vaadin.Flow && window.Vaadin.Flow.clients) {\n            var flowVersions = Object.keys(window.Vaadin.Flow.clients).map(function (key) {\n              return window.Vaadin.Flow.clients[key];\n            }).filter(function (client) {\n              return client.getVersionInfo;\n            }).map(function (client) {\n              return client.getVersionInfo().flow;\n            });\n            if (flowVersions.length > 0) {\n              return flowVersions[0];\n            }\n          }\n        },\n        'Vaadin Framework': function VaadinFramework() {\n          if (window.vaadin && window.vaadin.clients) {\n            var frameworkVersions = Object.values(window.vaadin.clients).filter(function (client) {\n              return client.getVersionInfo;\n            }).map(function (client) {\n              return client.getVersionInfo().vaadinVersion;\n            });\n            if (frameworkVersions.length > 0) {\n              return frameworkVersions[0];\n            }\n          }\n        },\n        'AngularJs': function AngularJs() {\n          if (window.angular && window.angular.version && window.angular.version) {\n            return window.angular.version.full;\n          }\n        },\n        'Angular': function Angular() {\n          if (window.ng) {\n            var tags = document.querySelectorAll(\"[ng-version]\");\n            if (tags.length > 0) {\n              return tags[0].getAttribute(\"ng-version\");\n            }\n            return \"Unknown\";\n          }\n        },\n        'Backbone.js': function BackboneJs() {\n          if (window.Backbone) {\n            return window.Backbone.VERSION;\n          }\n        },\n        'React': function React() {\n          var reactSelector = '[data-reactroot], [data-reactid]';\n          if (!!document.querySelector(reactSelector)) {\n            // React does not publish the version by default\n            return \"unknown\";\n          }\n        },\n        'Ember': function Ember() {\n          if (window.Em && window.Em.VERSION) {\n            return window.Em.VERSION;\n          } else if (window.Ember && window.Ember.VERSION) {\n            return window.Ember.VERSION;\n          }\n        },\n        'jQuery': function (_jQuery) {\n          function jQuery() {\n            return _jQuery.apply(this, arguments);\n          }\n\n          jQuery.toString = function () {\n            return _jQuery.toString();\n          };\n\n          return jQuery;\n        }(function () {\n          if (typeof jQuery === 'function' && jQuery.prototype.jquery !== undefined) {\n            return jQuery.prototype.jquery;\n          }\n        }),\n        'Polymer': function Polymer() {\n          var version = getPolymerVersion();\n          if (version) {\n            return version;\n          }\n        },\n        'LitElement': function LitElement() {\n          var version = window.litElementVersions && window.litElementVersions[0];\n          if (version) {\n            return version;\n          }\n        },\n        'LitHtml': function LitHtml() {\n          var version = window.litHtmlVersions && window.litHtmlVersions[0];\n          if (version) {\n            return version;\n          }\n        },\n        'Vue.js': function VueJs() {\n          if (window.Vue) {\n            return window.Vue.version;\n          }\n        }\n      };\n    }\n  }, {\n    key: 'getUsedVaadinElements',\n    value: function getUsedVaadinElements(elements) {\n      var version = getPolymerVersion();\n      var elementClasses = void 0;\n      // NOTE: In case you edit the code here, YOU MUST UPDATE any statistics reporting code in Flow.\n      // Check all locations calling the method getEntries() in\n      // https://github.com/vaadin/flow/blob/master/flow-server/src/main/java/com/vaadin/flow/internal/UsageStatistics.java#L106\n      // Currently it is only used by BootstrapHandler.\n      if (version && version.indexOf('2') === 0) {\n        // Polymer 2: components classes are stored in window.Vaadin\n        elementClasses = Object.keys(window.Vaadin).map(function (c) {\n          return window.Vaadin[c];\n        }).filter(function (c) {\n          return c.is;\n        });\n      } else {\n        // Polymer 3: components classes are stored in window.Vaadin.registrations\n        elementClasses = window.Vaadin.registrations || [];\n      }\n      elementClasses.forEach(function (klass) {\n        var version = klass.version ? klass.version : \"0.0.0\";\n        elements[klass.is] = { version: version };\n      });\n    }\n  }, {\n    key: 'getUsedVaadinThemes',\n    value: function getUsedVaadinThemes(themes) {\n      ['Lumo', 'Material'].forEach(function (themeName) {\n        var theme;\n        var version = getPolymerVersion();\n        if (version && version.indexOf('2') === 0) {\n          // Polymer 2: themes are stored in window.Vaadin\n          theme = window.Vaadin[themeName];\n        } else {\n          // Polymer 3: themes are stored in custom element registry\n          theme = customElements.get('vaadin-' + themeName.toLowerCase() + '-styles');\n        }\n        if (theme && theme.version) {\n          themes[themeName] = { version: theme.version };\n        }\n      });\n    }\n  }, {\n    key: 'getFrameworks',\n    value: function getFrameworks(frameworks) {\n      var detectors = this.frameworkVersionDetectors();\n      Object.keys(detectors).forEach(function (framework) {\n        var detector = detectors[framework];\n        try {\n          var version = detector();\n          if (version) {\n            frameworks[framework] = { version: version };\n          }\n        } catch (e) {}\n      });\n    }\n  }, {\n    key: 'gather',\n    value: function gather(storage) {\n      var storedStats = storage.read();\n      var gatheredStats = {};\n      var types = [\"elements\", \"frameworks\", \"themes\"];\n\n      types.forEach(function (type) {\n        gatheredStats[type] = {};\n        if (!storedStats[type]) {\n          storedStats[type] = {};\n        }\n      });\n\n      var previousStats = JSON.stringify(storedStats);\n\n      this.getUsedVaadinElements(gatheredStats.elements);\n      this.getFrameworks(gatheredStats.frameworks);\n      this.getUsedVaadinThemes(gatheredStats.themes);\n\n      var now = this.now;\n      types.forEach(function (type) {\n        var keys = Object.keys(gatheredStats[type]);\n        keys.forEach(function (key) {\n          if (!storedStats[type][key] || _typeof(storedStats[type][key]) != _typeof({})) {\n            storedStats[type][key] = { firstUsed: now };\n          }\n          // Discards any previously logged version number\n          storedStats[type][key].version = gatheredStats[type][key].version;\n          storedStats[type][key].lastUsed = now;\n        });\n      });\n\n      var newStats = JSON.stringify(storedStats);\n      storage.write(newStats);\n      if (newStats != previousStats && Object.keys(storedStats).length > 0) {\n        this.logger.debug(\"New stats: \" + newStats);\n      }\n    }\n  }]);\n  return StatisticsGatherer;\n}();\n\nvar StatisticsStorage = function () {\n  function StatisticsStorage(key) {\n    classCallCheck(this, StatisticsStorage);\n\n    this.key = key;\n  }\n\n  createClass(StatisticsStorage, [{\n    key: 'read',\n    value: function read() {\n      var localStorageStatsString = localStorage.getItem(this.key);\n      try {\n        return JSON.parse(localStorageStatsString ? localStorageStatsString : '{}');\n      } catch (e) {\n        return {};\n      }\n    }\n  }, {\n    key: 'write',\n    value: function write(data) {\n      localStorage.setItem(this.key, data);\n    }\n  }, {\n    key: 'clear',\n    value: function clear() {\n      localStorage.removeItem(this.key);\n    }\n  }, {\n    key: 'isEmpty',\n    value: function isEmpty() {\n      var storedStats = this.read();\n      var empty = true;\n      Object.keys(storedStats).forEach(function (key) {\n        if (Object.keys(storedStats[key]).length > 0) {\n          empty = false;\n        }\n      });\n\n      return empty;\n    }\n  }]);\n  return StatisticsStorage;\n}();\n\nvar StatisticsSender = function () {\n  function StatisticsSender(url, logger) {\n    classCallCheck(this, StatisticsSender);\n\n    this.url = url;\n    this.logger = logger;\n  }\n\n  createClass(StatisticsSender, [{\n    key: 'send',\n    value: function send(data, errorHandler) {\n      var logger = this.logger;\n\n      if (navigator.onLine === false) {\n        logger.debug(\"Offline, can't send\");\n        errorHandler();\n        return;\n      }\n      logger.debug(\"Sending data to \" + this.url);\n\n      var req = new XMLHttpRequest();\n      req.withCredentials = true;\n      req.addEventListener(\"load\", function () {\n        // Stats sent, nothing more to do\n        logger.debug(\"Response: \" + req.responseText);\n      });\n      req.addEventListener(\"error\", function () {\n        logger.debug(\"Send failed\");\n        errorHandler();\n      });\n      req.addEventListener(\"abort\", function () {\n        logger.debug(\"Send aborted\");\n        errorHandler();\n      });\n      req.open(\"POST\", this.url);\n      req.setRequestHeader(\"Content-Type\", \"application/json\");\n      req.send(data);\n    }\n  }]);\n  return StatisticsSender;\n}();\n\nvar StatisticsLogger = function () {\n  function StatisticsLogger(id) {\n    classCallCheck(this, StatisticsLogger);\n\n    this.id = id;\n  }\n\n  createClass(StatisticsLogger, [{\n    key: '_isDebug',\n    value: function _isDebug() {\n      return localStorage.getItem(\"vaadin.\" + this.id + \".debug\");\n    }\n  }, {\n    key: 'debug',\n    value: function debug(msg) {\n      if (this._isDebug()) {\n        console.info(this.id + \": \" + msg);\n      }\n    }\n  }]);\n  return StatisticsLogger;\n}();\n\nvar UsageStatistics = function () {\n  function UsageStatistics() {\n    classCallCheck(this, UsageStatistics);\n\n    this.now = new Date();\n    this.timeNow = this.now.getTime();\n    this.gatherDelay = 10; // Delay between loading this file and gathering stats\n    this.initialDelay = 24 * 60 * 60;\n\n    this.logger = new StatisticsLogger(\"statistics\");\n    this.storage = new StatisticsStorage(\"vaadin.statistics.basket\");\n    this.gatherer = new StatisticsGatherer(this.logger);\n    this.sender = new StatisticsSender(\"https://tools.vaadin.com/usage-stats/submit\", this.logger);\n  }\n\n  createClass(UsageStatistics, [{\n    key: 'maybeGatherAndSend',\n    value: function maybeGatherAndSend() {\n      var _this = this;\n\n      if (localStorage.getItem(UsageStatistics.optOutKey)) {\n        return;\n      }\n      this.gatherer.gather(this.storage);\n      setTimeout(function () {\n        _this.maybeSend();\n      }, this.gatherDelay * 1000);\n    }\n  }, {\n    key: 'lottery',\n    value: function lottery() {\n      return true;\n    }\n  }, {\n    key: 'currentMonth',\n    value: function currentMonth() {\n      return this.now.getYear() * 12 + this.now.getMonth();\n    }\n  }, {\n    key: 'maybeSend',\n    value: function maybeSend() {\n      var firstUse = Number(localStorage.getItem(UsageStatistics.firstUseKey));\n      var monthProcessed = Number(localStorage.getItem(UsageStatistics.monthProcessedKey));\n\n      if (!firstUse) {\n        // Use a grace period to avoid interfering with tests, incognito mode etc\n        firstUse = this.timeNow;\n        localStorage.setItem(UsageStatistics.firstUseKey, firstUse);\n      }\n\n      if (this.timeNow < firstUse + this.initialDelay * 1000) {\n        this.logger.debug(\"No statistics will be sent until the initial delay of \" + this.initialDelay + \"s has passed\");\n        return;\n      }\n      if (this.currentMonth() <= monthProcessed) {\n        this.logger.debug(\"This month has already been processed\");\n        return;\n      }\n      localStorage.setItem(UsageStatistics.monthProcessedKey, this.currentMonth());\n      // Use random sampling\n      if (this.lottery()) {\n        this.logger.debug(\"Congratulations, we have a winner!\");\n      } else {\n        this.logger.debug(\"Sorry, no stats from you this time\");\n        return;\n      }\n\n      this.send();\n    }\n  }, {\n    key: 'send',\n    value: function send() {\n      // Ensure we have the latest data\n      this.gatherer.gather(this.storage);\n\n      // Read, send and clean up\n      var data = this.storage.read();\n      data[\"firstUse\"] = Number(localStorage.getItem(UsageStatistics.firstUseKey));\n      data[\"usageStatisticsVersion\"] = UsageStatistics.version;\n      var info = 'This request contains usage statistics gathered from the application running in development mode. \\n\\nStatistics gathering is automatically disabled and excluded from production builds.\\n\\nFor details and to opt-out, see https://github.com/vaadin/vaadin-usage-statistics.\\n\\n\\n\\n';\n      var self = this;\n      this.sender.send(info + JSON.stringify(data), function () {\n        // Revert the 'month processed' flag\n        localStorage.setItem(UsageStatistics.monthProcessedKey, self.currentMonth() - 1);\n      });\n    }\n  }], [{\n    key: 'version',\n    get: function get$1() {\n      return '2.1.2';\n    }\n  }, {\n    key: 'firstUseKey',\n    get: function get$1() {\n      return 'vaadin.statistics.firstuse';\n    }\n  }, {\n    key: 'monthProcessedKey',\n    get: function get$1() {\n      return 'vaadin.statistics.monthProcessed';\n    }\n  }, {\n    key: 'optOutKey',\n    get: function get$1() {\n      return 'vaadin.statistics.optout';\n    }\n  }]);\n  return UsageStatistics;\n}();\n\ntry {\n  window.Vaadin = window.Vaadin || {};\n  window.Vaadin.usageStatsChecker = window.Vaadin.usageStatsChecker || new UsageStatistics();\n  window.Vaadin.usageStatsChecker.maybeGatherAndSend();\n} catch (e) {\n  // Intentionally ignored as this is not a problem in the app being developed\n}\n\n}());\n\n  vaadin-dev-mode:end **/\n}\n\nconst usageStatistics = function() {\n  if (typeof runIfDevelopmentMode === 'function') {\n    return runIfDevelopmentMode(maybeGatherAndSendStats);\n  }\n};\n\nwindow.Vaadin = window.Vaadin || {};\nwindow.Vaadin.registrations = window.Vaadin.registrations || [];\n\nwindow.Vaadin.registrations.push({\n  is: '@vaadin/router',\n  version: '1.7.4',\n});\n\nusageStatistics();\n\nRouter.NavigationTrigger = {POPSTATE, CLICK};\n\nexport { Resolver, Router };\n//# sourceMappingURL=vaadin-router.js.map\n","import type { Params } from '@vaadin/router';\nimport { Router } from '@vaadin/router';\n\nexport enum BlogRoutes {\n  HOME = 'home',\n  POST = 'post',\n  SEARCH = 'search',\n  CATEGORY = 'category',\n  TAG = 'tag',\n  DRAFT = 'draft',\n}\n\nexport function getRouter(): Router {\n  return (window as any)['sy-app-router'];\n}\n\nexport function urlFor(name: BlogRoutes, params?: Params): string {\n  let path: string;\n  try {\n    path = getRouter().urlForName(name, params);\n  } catch (error) {\n    console.warn(error.message);\n    path = getRouter().urlForName(BlogRoutes.HOME);\n  }\n\n  return removeBaseUrl(path);\n}\n\nexport function go(name: BlogRoutes, params?: Params): boolean {\n  const path = urlFor(name, params);\n  return goToPath(path);\n}\n\nexport function goToPath(path: string): boolean {\n  return Router.go(path);\n}\n\nfunction removeBaseUrl(path: string): string {\n  return path.replace(getRouter().baseUrl, '');\n}\n"]}