/******/ (() => { // webpackBootstrap

/******/ 	"use strict";

/******/ 	// The require scope

/******/ 	var __webpack_require__ = {};

/******/ 	

/************************************************************************/

/******/ 	/* webpack/runtime/define property getters */

/******/ 	(() => {

/******/ 		// define getter functions for harmony exports

/******/ 		__webpack_require__.d = (exports, definition) => {

/******/ 			for(var key in definition) {

/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {

/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });

/******/ 				}

/******/ 			}

/******/ 		};

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/hasOwnProperty shorthand */

/******/ 	(() => {

/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/make namespace object */

/******/ 	(() => {

/******/ 		// define __esModule on exports

/******/ 		__webpack_require__.r = (exports) => {

/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

/******/ 			}

/******/ 			Object.defineProperty(exports, '__esModule', { value: true });

/******/ 		};

/******/ 	})();

/******/ 	

/************************************************************************/

var __webpack_exports__ = {};

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

  privateApis: () => (/* reexport */ privateApis)

});

;// ./node_modules/route-recognizer/dist/route-recognizer.es.js

var createObject = Object.create;

function createMap() {

    var map = createObject(null);

    map["__"] = undefined;

    delete map["__"];

    return map;

}

var Target = function Target(path, matcher, delegate) {

    this.path = path;

    this.matcher = matcher;

    this.delegate = delegate;

};

Target.prototype.to = function to (target, callback) {

    var delegate = this.delegate;

    if (delegate && delegate.willAddRoute) {

        target = delegate.willAddRoute(this.matcher.target, target);

    }

    this.matcher.add(this.path, target);

    if (callback) {

        if (callback.length === 0) {

            throw new Error("You must have an argument in the function passed to `to`");

        }

        this.matcher.addChild(this.path, target, callback, this.delegate);

    }

};

var Matcher = function Matcher(target) {

    this.routes = createMap();

    this.children = createMap();

    this.target = target;

};

Matcher.prototype.add = function add (path, target) {

    this.routes[path] = target;

};

Matcher.prototype.addChild = function addChild (path, target, callback, delegate) {

    var matcher = new Matcher(target);

    this.children[path] = matcher;

    var match = generateMatch(path, matcher, delegate);

    if (delegate && delegate.contextEntered) {

        delegate.contextEntered(target, match);

    }

    callback(match);

};

function generateMatch(startingPath, matcher, delegate) {

    function match(path, callback) {

        var fullPath = startingPath + path;

        if (callback) {

            callback(generateMatch(fullPath, matcher, delegate));

        }

        else {

            return new Target(fullPath, matcher, delegate);

        }

    }

    return match;

}

function addRoute(routeArray, path, handler) {

    var len = 0;

    for (var i = 0; i < routeArray.length; i++) {

        len += routeArray[i].path.length;

    }

    path = path.substr(len);

    var route = { path: path, handler: handler };

    routeArray.push(route);

}

function eachRoute(baseRoute, matcher, callback, binding) {

    var routes = matcher.routes;

    var paths = Object.keys(routes);

    for (var i = 0; i < paths.length; i++) {

        var path = paths[i];

        var routeArray = baseRoute.slice();

        addRoute(routeArray, path, routes[path]);

        var nested = matcher.children[path];

        if (nested) {

            eachRoute(routeArray, nested, callback, binding);

        }

        else {

            callback.call(binding, routeArray);

        }

    }

}

var map = function (callback, addRouteCallback) {

    var matcher = new Matcher();

    callback(generateMatch("", matcher, this.delegate));

    eachRoute([], matcher, function (routes) {

        if (addRouteCallback) {

            addRouteCallback(this, routes);

        }

        else {

            this.add(routes);

        }

    }, this);

};

// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded

// values that are not reserved (i.e., unicode characters, emoji, etc). The reserved

// chars are "/" and "%".

// Safe to call multiple times on the same path.

// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded

function normalizePath(path) {

    return path.split("/")

        .map(normalizeSegment)

        .join("/");

}

// We want to ensure the characters "%" and "/" remain in percent-encoded

// form when normalizing paths, so replace them with their encoded form after

// decoding the rest of the path

var SEGMENT_RESERVED_CHARS = /%|\//g;

function normalizeSegment(segment) {

    if (segment.length < 3 || segment.indexOf("%") === -1)

        { return segment; }

    return decodeURIComponent(segment).replace(SEGMENT_RESERVED_CHARS, encodeURIComponent);

}

// We do not want to encode these characters when generating dynamic path segments

// See https://tools.ietf.org/html/rfc3986#section-3.3

// sub-delims: "!", "$", "&", "'", "(", ")", "*", "+", ",", ";", "="

// others allowed by RFC 3986: ":", "@"

//

// First encode the entire path segment, then decode any of the encoded special chars.

//

// The chars "!", "'", "(", ")", "*" do not get changed by `encodeURIComponent`,

// so the possible encoded chars are:

// ['%24', '%26', '%2B', '%2C', '%3B', '%3D', '%3A', '%40'].

var PATH_SEGMENT_ENCODINGS = /%(?:2(?:4|6|B|C)|3(?:B|D|A)|40)/g;

function encodePathSegment(str) {

    return encodeURIComponent(str).replace(PATH_SEGMENT_ENCODINGS, decodeURIComponent);

}

var escapeRegex = /(\/|\.|\*|\+|\?|\||\(|\)|\[|\]|\{|\}|\\)/g;

var isArray = Array.isArray;

var route_recognizer_es_hasOwnProperty = Object.prototype.hasOwnProperty;

function getParam(params, key) {

    if (typeof params !== "object" || params === null) {

        throw new Error("You must pass an object as the second argument to `generate`.");

    }

    if (!route_recognizer_es_hasOwnProperty.call(params, key)) {

        throw new Error("You must provide param `" + key + "` to `generate`.");

    }

    var value = params[key];

    var str = typeof value === "string" ? value : "" + value;

    if (str.length === 0) {

        throw new Error("You must provide a param `" + key + "`.");

    }

    return str;

}

var eachChar = [];

eachChar[0 /* Static */] = function (segment, currentState) {

    var state = currentState;

    var value = segment.value;

    for (var i = 0; i < value.length; i++) {

        var ch = value.charCodeAt(i);

        state = state.put(ch, false, false);

    }

    return state;

};

eachChar[1 /* Dynamic */] = function (_, currentState) {

    return currentState.put(47 /* SLASH */, true, true);

};

eachChar[2 /* Star */] = function (_, currentState) {

    return currentState.put(-1 /* ANY */, false, true);

};

eachChar[4 /* Epsilon */] = function (_, currentState) {

    return currentState;

};

var regex = [];

regex[0 /* Static */] = function (segment) {

    return segment.value.replace(escapeRegex, "\\$1");

};

regex[1 /* Dynamic */] = function () {

    return "([^/]+)";

};

regex[2 /* Star */] = function () {

    return "(.+)";

};

regex[4 /* Epsilon */] = function () {

    return "";

};

var generate = [];

generate[0 /* Static */] = function (segment) {

    return segment.value;

};

generate[1 /* Dynamic */] = function (segment, params) {

    var value = getParam(params, segment.value);

    if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {

        return encodePathSegment(value);

    }

    else {

        return value;

    }

};

generate[2 /* Star */] = function (segment, params) {

    return getParam(params, segment.value);

};

generate[4 /* Epsilon */] = function () {

    return "";

};

var EmptyObject = Object.freeze({});

var EmptyArray = Object.freeze([]);

// The `names` will be populated with the paramter name for each dynamic/star

// segment. `shouldDecodes` will be populated with a boolean for each dyanamic/star

// segment, indicating whether it should be decoded during recognition.

function parse(segments, route, types) {

    // normalize route as not starting with a "/". Recognition will

    // also normalize.

    if (route.length > 0 && route.charCodeAt(0) === 47 /* SLASH */) {

        route = route.substr(1);

    }

    var parts = route.split("/");

    var names = undefined;

    var shouldDecodes = undefined;

    for (var i = 0; i < parts.length; i++) {

        var part = parts[i];

        var flags = 0;

        var type = 0;

        if (part === "") {

            type = 4 /* Epsilon */;

        }

        else if (part.charCodeAt(0) === 58 /* COLON */) {

            type = 1 /* Dynamic */;

        }

        else if (part.charCodeAt(0) === 42 /* STAR */) {

            type = 2 /* Star */;

        }

        else {

            type = 0 /* Static */;

        }

        flags = 2 << type;

        if (flags & 12 /* Named */) {

            part = part.slice(1);

            names = names || [];

            names.push(part);

            shouldDecodes = shouldDecodes || [];

            shouldDecodes.push((flags & 4 /* Decoded */) !== 0);

        }

        if (flags & 14 /* Counted */) {

            types[type]++;

        }

        segments.push({

            type: type,

            value: normalizeSegment(part)

        });

    }

    return {

        names: names || EmptyArray,

        shouldDecodes: shouldDecodes || EmptyArray,

    };

}

function isEqualCharSpec(spec, char, negate) {

    return spec.char === char && spec.negate === negate;

}

// A State has a character specification and (`charSpec`) and a list of possible

// subsequent states (`nextStates`).

//

// If a State is an accepting state, it will also have several additional

// properties:

//

// * `regex`: A regular expression that is used to extract parameters from paths

//   that reached this accepting state.

// * `handlers`: Information on how to convert the list of captures into calls

//   to registered handlers with the specified parameters

// * `types`: How many static, dynamic or star segments in this route. Used to

//   decide which route to use if multiple registered routes match a path.

//

// Currently, State is implemented naively by looping over `nextStates` and

// comparing a character specification against a character. A more efficient

// implementation would use a hash of keys pointing at one or more next states.

var State = function State(states, id, char, negate, repeat) {

    this.states = states;

    this.id = id;

    this.char = char;

    this.negate = negate;

    this.nextStates = repeat ? id : null;

    this.pattern = "";

    this._regex = undefined;

    this.handlers = undefined;

    this.types = undefined;

};

State.prototype.regex = function regex$1 () {

    if (!this._regex) {

        this._regex = new RegExp(this.pattern);

    }

    return this._regex;

};

State.prototype.get = function get (char, negate) {

        var this$1 = this;

    var nextStates = this.nextStates;