@rxdi/router 0.7.220 → 0.7.222

package/dist/vaadin/vaadin-router.js

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