+
+
+
+
+
+
+
+
+
diff --git a/MiniIndex/ClientApp/package.json b/MiniIndex/ClientApp/package.json
new file mode 100644
index 0000000..294397f
--- /dev/null
+++ b/MiniIndex/ClientApp/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "clientapp",
+ "private": true,
+ "version": "0.0.0",
+ "type": "module",
+ "scripts": {
+ "dev": "vite",
+ "build": "tsc && vite build",
+ "preview": "vite preview"
+ },
+ "dependencies": {
+ "@vaadin/router": "^1.7.4",
+ "lit": "^2.3.1",
+ "oidc-client": "^1.11.5"
+ },
+ "devDependencies": {
+ "typescript": "^4.6.4",
+ "vite": "^3.0.7"
+ }
+}
diff --git a/MiniIndex/ClientApp/public/vite.svg b/MiniIndex/ClientApp/public/vite.svg
new file mode 100644
index 0000000..e7b8dfb
--- /dev/null
+++ b/MiniIndex/ClientApp/public/vite.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/MiniIndex/ClientApp/src/api-authorization/AuthorizeRoute.js b/MiniIndex/ClientApp/src/api-authorization/AuthorizeRoute.js
new file mode 100644
index 0000000..e284bc0
--- /dev/null
+++ b/MiniIndex/ClientApp/src/api-authorization/AuthorizeRoute.js
@@ -0,0 +1,52 @@
+import React from "react";
+import { Component } from "react";
+import { Navigate } from "react-router-dom";
+import authService from "./AuthorizeService";
+
+export default class AuthorizeRoute extends Component {
+ constructor(props) {
+ super(props);
+
+ this.state = {
+ ready: false,
+ authenticated: false,
+ };
+ }
+
+ componentDidMount() {
+ this._subscription = authService.subscribe(() =>
+ this.authenticationChanged()
+ );
+ this.populateAuthenticationState();
+ }
+
+ componentWillUnmount() {
+ authService.unsubscribe(this._subscription);
+ }
+
+ render() {
+ const { ready, authenticated } = this.state;
+ var link = document.createElement("a");
+ link.href = this.props.path;
+ const returnUrl = `${link.protocol}//${link.host}${link.pathname}${link.search}${link.hash}`;
+ const redirectUrl = `${ApplicationPaths.Login}?${
+ QueryParameterNames.ReturnUrl
+ }=${encodeURIComponent(returnUrl)}`;
+ if (!ready) {
+ return ;
+ } else {
+ const { element } = this.props;
+ return authenticated ? element :
+ Logout
+
`;
+ } else {
+ return html`
+ Login
+
`;
+ }
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "tmi-auth-cluster": TMIAuthCluster;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/components/tmi-mini-card.ts b/MiniIndex/ClientApp/src/components/tmi-mini-card.ts
new file mode 100644
index 0000000..8cf2374
--- /dev/null
+++ b/MiniIndex/ClientApp/src/components/tmi-mini-card.ts
@@ -0,0 +1,157 @@
+//3rd Party Imports
+import { LitElement, html, css } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { Router } from "@vaadin/router";
+
+//1st Party Imports
+
+//Style and Component Imports
+import { fontStyles } from "../styles/font-styles.js";
+
+@customElement("tmi-mini-card")
+export class TMIMiniCard extends LitElement {
+ static override styles = [
+ fontStyles,
+ css`
+ :host {
+ display: block;
+ }
+ a.card {
+ color: var(--app-primary-color);
+ height: 100%;
+ }
+
+ .card {
+ filter: drop-shadow(4px 4px 4px var(--app-primary-color));
+ background-color: white;
+ border-radius: 2px;
+ }
+
+ .card-thumbnail {
+ object-fit: cover;
+ border-radius: 2px 2px 0px 0px;
+ width: 100%;
+ }
+
+ .card-text {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ width: 100%;
+ }
+
+ .card-padded {
+ padding: 0.5rem;
+ }
+
+ .mini-name {
+ text-align: left;
+ line-height: 0.4em;
+ white-space: nowrap;
+ overflow: hidden;
+ margin: 0 !important;
+ }
+
+ .mini-name > h3,
+ .mini-name > h4 {
+ margin: 0.5rem;
+ }
+
+ .new-tag {
+ width: 0;
+ height: 0;
+ border-bottom: 60px solid #00201c;
+ border-left: 80px solid transparent;
+ position: absolute;
+ right: 0px;
+ bottom: 0px;
+ z-index: 99;
+ -webkit-filter: drop-shadow(-2px -2px 4px #40a076);
+ filter: drop-shadow(-2px -2px 4px #40a076);
+ }
+
+ .new-tag-span {
+ position: relative;
+ bottom: -29px;
+ right: 55px;
+ z-index: 100;
+ width: 60px;
+ text-align: center;
+ font-size: 13px;
+ font-family: arial;
+ transform: rotate(-37deg);
+ font-weight: 600;
+ color: white;
+ display: block;
+ }
+
+ .mini-banner {
+ background-color: #fff7b9;
+ margin-top: -4px;
+ padding: 0.5rem;
+ }
+
+ .hidden {
+ display: none !important;
+ }
+
+ .approved-time {
+ display: none;
+ }
+ `,
+ ];
+ @property() name = "";
+ @property() status = "";
+ @property() miniId = "";
+ @property() thumbnail = "";
+ @property() creatorId = "";
+ @property() creatorName = "";
+ @property() approvedTime = "";
+
+ async view(id: string) {
+ Router.go(`/Mini/${id}`);
+ }
+
+ //TODO: Banner for needs tags.
+ override render() {
+ console.log(this);
+ return html`
+
+
+ `;
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "tmi-mini-card": TMIMiniCard;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/components/tmi-related-minis.ts b/MiniIndex/ClientApp/src/components/tmi-related-minis.ts
new file mode 100644
index 0000000..788ddb4
--- /dev/null
+++ b/MiniIndex/ClientApp/src/components/tmi-related-minis.ts
@@ -0,0 +1,64 @@
+//3rd Party Imports
+import { LitElement, html, css } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+
+//1st Party Imports
+import authService from "../utils/AuthorizeService.js";
+import { perfMark, perfMeasure } from "../utils/PerformanceMarks";
+
+//Style and Component Imports
+import "../components/tmi-mini-card.js";
+import { miniListStyles } from "../styles/layout-styles.js";
+
+@customElement("tmi-related-minis")
+export class TMIRelatedMinis extends LitElement {
+ static override styles = [miniListStyles, css``];
+
+ @property() miniId = 0;
+ @state() _data = [];
+ @state() _loading = true;
+
+ async firstUpdated() {
+ perfMark("tmi-getRelatedMinis-start");
+ const token = await authService.getAccessToken();
+ const response = await fetch(`/api/Minis/${this.miniId}/Related`, {
+ headers: !token ? {} : { Authorization: `Bearer ${token}` },
+ });
+ this._data = await response.json();
+ perfMark("tmi-getRelatedMinis-end");
+ perfMeasure(
+ "tmi-getRelatedMinis",
+ "tmi-getRelatedMinis-start",
+ "tmi-getRelatedMinis-end"
+ );
+ this._loading = false;
+ }
+
+ override render() {
+ console.log(this._data);
+ return html`
+
+ 
+
+
+
+
+
+
+
+
+ ${this.name}
+ ${this.creatorName + ? html`+ by + ${this.creatorName} +
` + : ""} +${this.approvedTime}
+
+ ${this._loading
+ ? html`Loading`
+ : this._data.length > 0
+ ? html`
`;
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "tmi-related-minis": TMIRelatedMinis;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/components/tmi-tag-manager.ts b/MiniIndex/ClientApp/src/components/tmi-tag-manager.ts
new file mode 100644
index 0000000..75800f7
--- /dev/null
+++ b/MiniIndex/ClientApp/src/components/tmi-tag-manager.ts
@@ -0,0 +1,145 @@
+//3rd Party Imports
+import { LitElement, html, css } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+
+//1st Party Imports
+import authService from "../utils/AuthorizeService.js";
+import { Tag } from "../utils/minis.js";
+import { perfMark, perfMeasure } from "../utils/PerformanceMarks";
+
+//Style and Component Imports
+import { buttonStyles } from "../styles/button-styles.js";
+import { switcherStyles } from "../styles/layout-styles.js";
+import { fontStyles } from "../styles/font-styles.js";
+
+@customElement("tmi-tag-manager")
+export class TMITagManager extends LitElement {
+ static override styles = [fontStyles, switcherStyles, buttonStyles, css``];
+
+ @property() miniId = "";
+ @state() _deletedTags: Tag[] = [];
+ @state() _pendingTags: Tag[] = [];
+ @state() _tagSearchResults: String[] = [];
+ //TODO: Make a tag suggestion API and hook this up right.
+ @state() _suggestedTags: Tag[] = [];
+
+ async firstUpdated() {
+ this._updateTagLists();
+ }
+
+ //TODO: Handle errors
+ private async _updateTagLists() {
+ perfMark("tmi-updateTags-start");
+ const response = await fetch(
+ "https://localhost:44386/api/Minis/" + this.miniId + "/Tags"
+ );
+ const data = await response.json();
+ this._pendingTags = [];
+ this._deletedTags = [];
+
+ data.forEach((tag: Tag) => {
+ if (tag.Status === "Pending") {
+ this._pendingTags.push(tag);
+ } else if (tag.Status === "Deleted" || tag.Status === "Rejected") {
+ this._deletedTags.push(tag);
+ }
+ });
+
+ perfMark("tmi-updateTags-end");
+ perfMeasure("tmi-updateTags", "tmi-updateTags-start", "tmi-updateTags-end");
+ }
+
+ //TODO: Add a fancy multi-action button for controlling state
+ private _printTagList(tagList: Tag[]) {
+ if (tagList.length === 0) return "No tags";
+ let html = "";
+ tagList.forEach((tag: Tag) => {
+ html += tag.TagName + " ";
+ });
+ return html;
+ }
+
+ //TODO: Remove any existing tags
+ private async _typeahead(e: any) {
+ if (e.target.value.length < 2) return;
+ perfMark("tmi-searchTags-start");
+ const token = await authService.getAccessToken();
+ const response = await fetch(
+ "https://localhost:44386/api/Tags?search=" + e.target.value,
+ {
+ headers: !token ? {} : { Authorization: `Bearer ${token}` },
+ }
+ );
+ this._tagSearchResults = await response.json();
+
+ perfMark("tmi-searchTags-end");
+ perfMeasure("tmi-searchTags", "tmi-searchTags-start", "tmi-searchTags-end");
+ }
+
+ private async _addTag(tag: string) {
+ console.log("adding " + tag);
+ perfMark("tmi-addTag-start");
+ var miniTagData = {
+ Mini: {
+ ID: this.miniId * 1,
+ },
+ Tag: {
+ TagName: tag,
+ },
+ };
+
+ const token = await authService.getAccessToken();
+ const response = await fetch("https://localhost:44386/api/MiniTags", {
+ headers: !token
+ ? {}
+ : {
+ Authorization: `Bearer ${token}`,
+ "Content-Type": "application/json",
+ },
+ method: "POST",
+ body: JSON.stringify(miniTagData),
+ });
+
+ this._updateTagLists();
+ perfMark("tmi-addTag-end");
+ perfMeasure("tmi-addTag", "tmi-addTag-start", "tmi-addTag-end");
+ }
+
+ override render() {
+ return html`
+ -
+ ${this._data.map((item) => {
+ return html`
-
+
+ `;
+ })}
+
+
+ Suggested Tags
+ ${this._printTagList(this._suggestedTags)} ++
Tag Manually
+
+
+ `;
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "tmi-tag-manager": TMITagManager;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/main.ts b/MiniIndex/ClientApp/src/main.ts
new file mode 100644
index 0000000..149db9c
--- /dev/null
+++ b/MiniIndex/ClientApp/src/main.ts
@@ -0,0 +1,90 @@
+import "./pages/tmi-mini-list";
+import authService from "./utils/AuthorizeService";
+import { logMsg } from "./utils/PerformanceMarks";
+
+if (await authService.isAuthenticated()) {
+ logMsg("Authenticated:");
+ logMsg(await authService.getUser());
+} else {
+ logMsg("Not Authenticated...");
+ //await authService.signIn("https://localhost:44386/");
+}
+
+import { LitElement, css, html } from "lit";
+import { customElement } from "lit/decorators.js";
+import { Router } from "@vaadin/router";
+import "./styles/global.css";
+
+@customElement("app-index")
+export class AppIndex extends LitElement {
+ static get styles() {
+ return css`
+ main {
+ padding-left: 16px;
+ padding-right: 16px;
+ padding-bottom: 16px;
+ }
+ #routerOutlet > * {
+ width: 100% !important;
+ }
+ `;
+ }
+
+ constructor() {
+ super();
+ }
+
+ firstUpdated() {
+ // this method is a lifecycle even in lit
+ // for more info check out the lit docs https://lit.dev/docs/components/lifecycle/
+
+ // For more info on using the @vaadin/router check here https://vaadin.com/router
+ const router = new Router(this.shadowRoot?.querySelector("#routerOutlet"));
+ router.setRoutes([
+ // temporarily cast to any because of a Type bug with the router
+ {
+ path: (import.meta as any).env.BASE_URL,
+ animate: false,
+ children: [
+ { path: "", component: "tmi-mini-list" },
+ {
+ path: "/Minis",
+ component: "tmi-mini-list",
+ action: async () => {
+ await import("./pages/tmi-mini-list.js");
+ },
+ },
+ {
+ path: "/Mini/:id",
+ component: "tmi-mini-page",
+ action: async () => {
+ await import("./pages/tmi-mini-page.js");
+ },
+ },
+ {
+ path: "/authentication/login/:action",
+ component: "app-login",
+ action: async () => {
+ await import("./pages/tmi-login.js");
+ },
+ },
+ {
+ path: "/authentication/logout/:action",
+ component: "app-logout",
+ action: async () => {
+ await import("./pages/tmi-logout.js");
+ },
+ },
+ ],
+ } as any,
+ ]);
+ }
+
+ render() {
+ return html`
+
+
+
+ ${this._tagSearchResults.map( + (tag) => + html`` + )} +
+
+ + ${this._tagSearchResults.map( + (tag) => + html`` + )} +
+
+ Deleted Tags
+ ${this._printTagList(this._deletedTags)} +Pending Tags
+ ${this._printTagList(this._pendingTags)} +Hello, ${this.name}!
+ ++
${message}
`;
+ } else {
+ switch (action) {
+ case "login":
+ return html`Processing login
`;
+ case "login-callback":
+ return html`Processing login callback
`;
+ case "profile":
+ case "register":
+ return html``;
+ default:
+ throw new Error(`Invalid action '${action}'`);
+ }
+ }
+ }
+
+ async login(returnUrl: string) {
+ this.returnUrl = returnUrl;
+
+ const result = await authService.signIn(state);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ break;
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(returnUrl);
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.message = result.message;
+ break;
+ default:
+ throw new Error(`Invalid status result ${result.status}.`);
+ }
+ }
+
+ async processLoginCallback() {
+ const url = window.location.href;
+ const result = await authService.completeSignIn(url);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ // There should not be any redirects as the only time completeSignIn finishes
+ // is when we are doing a redirect sign in flow.
+ throw new Error("Should not redirect.");
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(this.getReturnUrl());
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.message = result.message;
+ break;
+ default:
+ throw new Error(
+ `Invalid authentication result status '${result.status}'.`
+ );
+ }
+ }
+
+ getReturnUrl() {
+ const params = new URLSearchParams(window.location.search);
+ const fromQuery = params.get("returnUrl");
+ if (fromQuery && !fromQuery.startsWith(`${window.location.origin}/`)) {
+ // This is an extra check to prevent open redirects.
+ throw new Error(
+ "Invalid return url. The return url needs to have the same origin as the current page."
+ );
+ }
+ return this.returnUrl || fromQuery || window.location.origin;
+ }
+
+ redirectToRegister() {
+ this.redirectToApiAuthorizationPath(
+ `Identity/Account/Register?$returnUrl=${encodeURI(this.returnUrl)}`
+ );
+ }
+
+ redirectToProfile() {
+ this.redirectToApiAuthorizationPath("Identity/Account/Manage");
+ }
+
+ redirectToApiAuthorizationPath(apiAuthorizationPath: string) {
+ const redirectUrl = `${window.location.origin}/${apiAuthorizationPath}`;
+ window.location.replace(redirectUrl);
+ }
+
+ navigateToReturnUrl(returnUrl: string) {
+ window.location.replace(returnUrl);
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "app-login": AppLogin;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/pages/tmi-logout.ts b/MiniIndex/ClientApp/src/pages/tmi-logout.ts
new file mode 100644
index 0000000..4a8e47c
--- /dev/null
+++ b/MiniIndex/ClientApp/src/pages/tmi-logout.ts
@@ -0,0 +1,143 @@
+import { LitElement, html } from "lit";
+import { customElement, state } from "lit/decorators.js";
+import { BeforeEnterObserver, RouterLocation } from "@vaadin/router";
+
+import authService from "../utils/AuthorizeService.js";
+import { AuthenticationResultStatus } from "../utils/AuthorizeService.js";
+
+// The main responsibility of this component is to handle the user's logout process.
+// This is the starting point for the logout process, which is usually initiated when a
+// user clicks on the logout button on the LoginMenu component.
+//TODO: Rename class and element name
+@customElement("app-logout")
+export class AppLogout extends LitElement implements BeforeEnterObserver {
+ @state()
+ message = "";
+
+ @state()
+ isReady = false;
+
+ @state()
+ authenticated = false;
+
+ @state()
+ returnUrl = "";
+
+ @state()
+ action = "";
+
+ onBeforeEnter(location: RouterLocation) {
+ this.action = location.params.action as string;
+ }
+
+ connectedCallback() {
+ const action = this.action;
+ switch (action) {
+ case "logout":
+ this.logout(this.getReturnUrl());
+
+ break;
+ case "logout-callback":
+ this.processLogoutCallback();
+ break;
+ case "logged-out":
+ //TODO: This message never shows?
+ this.message = "You successfully logged out!";
+ this.isReady = true;
+ break;
+ default:
+ throw new Error(`Invalid action '${action}'`);
+ }
+
+ this.populateAuthenticationState();
+ }
+
+ render() {
+ if (!this.isReady) {
+ return html``;
+ } else {
+ switch (this.action) {
+ case "logout":
+ return html`Processing logout
`;
+ case "logout-callback":
+ return html`Processing logout callback
`;
+ case "logged-out":
+ return html`${this.message}
`;
+ default:
+ throw new Error(`Invalid action '${this.action}'`);
+ }
+ }
+ }
+
+ async logout(returnUrl: string) {
+ this.returnUrl = returnUrl;
+ const isauthenticated = await authService.isAuthenticated();
+ if (isauthenticated) {
+ const result = await authService.signOut(state);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ break;
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(returnUrl);
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.message = result.message;
+ break;
+ default:
+ throw new Error("Invalid authentication result status.");
+ }
+ } else {
+ this.message = "You successfully logged out!";
+ }
+ }
+
+ async processLogoutCallback() {
+ const url = window.location.href;
+ const result = await authService.completeSignOut(url);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ // There should not be any redirects as the only time completeAuthentication finishes
+ // is when we are doing a redirect sign in flow.
+ throw new Error("Should not redirect.");
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(this.getReturnUrl());
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.message = result.message;
+ break;
+ default:
+ throw new Error("Invalid authentication result status.");
+ }
+ }
+
+ async populateAuthenticationState() {
+ this.authenticated = await authService.isAuthenticated();
+ this.isReady = true;
+ }
+
+ getReturnUrl() {
+ const params = new URLSearchParams(window.location.search);
+ const fromQuery = params.get("returnUrl");
+ if (fromQuery && !fromQuery.startsWith(`${window.location.origin}/`)) {
+ // This is an extra check to prevent open redirects.
+ throw new Error(
+ "Invalid return url. The return url needs to have the same origin as the current page."
+ );
+ }
+ return (
+ this.returnUrl ||
+ fromQuery ||
+ `${window.location.origin}/authentication/logout/logged-out`
+ );
+ }
+
+ navigateToReturnUrl(returnUrl: string) {
+ return window.location.replace(returnUrl);
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "app-logout": AppLogout;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/pages/tmi-mini-list.ts b/MiniIndex/ClientApp/src/pages/tmi-mini-list.ts
new file mode 100644
index 0000000..12c1950
--- /dev/null
+++ b/MiniIndex/ClientApp/src/pages/tmi-mini-list.ts
@@ -0,0 +1,55 @@
+//3rd Party Imports
+import { LitElement, html, css } from "lit";
+import { customElement, state } from "lit/decorators.js";
+
+//1st Party Imports
+import { getMinis, Mini } from "../utils/minis.js";
+
+//Style and Component Imports
+import "../components/tmi-mini-card.js";
+import { miniListStyles } from "../styles/layout-styles.js";
+
+//TODO: Refactor this to take in an array of Minis as a property.
+@customElement("tmi-mini-list")
+export class TMIMiniList extends LitElement {
+ static override styles = [miniListStyles, css``];
+
+ @state() _data: Mini[] | null = null;
+ @state() _loading: boolean = true;
+
+ async firstUpdated() {
+ this._data = await getMinis();
+ console.log(this._data);
+ this._loading = false;
+ }
+
+ override render() {
+ return html`
+ ${this._loading
+ ? html`Loading`
+ : this._data && this._data.length > 0
+ ? html`
`;
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "tmi-mini-list": TMIMiniList;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/pages/tmi-mini-page.ts b/MiniIndex/ClientApp/src/pages/tmi-mini-page.ts
new file mode 100644
index 0000000..db00537
--- /dev/null
+++ b/MiniIndex/ClientApp/src/pages/tmi-mini-page.ts
@@ -0,0 +1,165 @@
+//3rd Party Imports
+import { LitElement, html, css } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { BeforeEnterObserver, RouterLocation } from "@vaadin/router";
+
+//1st Party Imports
+import { getMiniDetail, DetailedMini, TagCategory } from "../utils/minis.js";
+
+//Style and Component Imports
+import "../components/tmi-action-button.js";
+import "../components/tmi-mini-card.js";
+//TODO: Can I delay loading some of these?
+import "../components/tmi-related-minis.js";
+import "../components/tmi-tag-manager.js";
+import { buttonStyles } from "../styles/button-styles.js";
+import { fontStyles } from "../styles/font-styles.js";
+import { switcherStyles, rowStyles } from "../styles/layout-styles.js";
+
+@customElement("tmi-mini-page")
+export class TMIMiniPage extends LitElement implements BeforeEnterObserver {
+ static override styles = [
+ buttonStyles,
+ fontStyles,
+ switcherStyles,
+ rowStyles,
+ css`
+ :host {
+ display: block;
+ }
+
+ .badge {
+ display: inline-block;
+ padding: 0.5rem 0.5rem;
+ margin: 0.25rem;
+ border-radius: 0.25rem;
+ }
+ `,
+ ];
+ @property() miniId: number | null = null;
+ @state() _data: DetailedMini | null = null;
+ @state() _loading: boolean = true;
+ //TODO: Favorites API and populate this
+ @state() _isFavorite: boolean | null = null;
+ //TODO: Save this between pages and sessions
+ @state() _isEditMode: boolean = true;
+
+ onBeforeEnter(location: RouterLocation) {
+ this.miniId = location.params.id;
+ }
+
+ connectedCallback() {
+ super.connectedCallback();
+ this._toggleFavorite = this._toggleFavorite.bind(this);
+ window.addEventListener("button-complete", this._toggleFavorite);
+ }
+ disconnectedCallback() {
+ window.removeEventListener("button-complete", this._toggleFavorite);
+ super.disconnectedCallback();
+ }
+
+ async firstUpdated() {
+ this._data = await getMiniDetail(this.miniId);
+ this._loading = false;
+ }
+
+ private _toggleFavorite() {
+ this._isFavorite = !this._isFavorite;
+ }
+
+ private _toggleEdit() {
+ this._isEditMode = !this._isEditMode;
+ }
+
+ override render() {
+ return html`-
+ ${this._data.map((item) => {
+ return html`
-
+
+ `;
+ })}
+
+ ${this._loading
+ ? html`Loading`
+ : this._data
+ ? html`
`;
+ }
+}
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "tmi-mini-page": TMIMiniPage;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/pages/tmi.about.ts b/MiniIndex/ClientApp/src/pages/tmi.about.ts
new file mode 100644
index 0000000..3d6e1b7
--- /dev/null
+++ b/MiniIndex/ClientApp/src/pages/tmi.about.ts
@@ -0,0 +1,49 @@
+//TODO: Do this.
+export {};
+/*
+
+*/
diff --git a/MiniIndex/ClientApp/src/style.css b/MiniIndex/ClientApp/src/style.css
new file mode 100644
index 0000000..ac37d84
--- /dev/null
+++ b/MiniIndex/ClientApp/src/style.css
@@ -0,0 +1,97 @@
+:root {
+ font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
+ font-size: 16px;
+ line-height: 24px;
+ font-weight: 400;
+
+ color-scheme: light dark;
+ color: rgba(255, 255, 255, 0.87);
+ background-color: #242424;
+
+ font-synthesis: none;
+ text-rendering: optimizeLegibility;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+ -webkit-text-size-adjust: 100%;
+}
+
+a {
+ font-weight: 500;
+ color: #646cff;
+ text-decoration: inherit;
+}
+a:hover {
+ color: #535bf2;
+}
+
+body {
+ margin: 0;
+ display: flex;
+ place-items: center;
+ min-width: 320px;
+ min-height: 100vh;
+}
+
+h1 {
+ font-size: 3.2em;
+ line-height: 1.1;
+}
+
+#app {
+ max-width: 1280px;
+ margin: 0 auto;
+ padding: 2rem;
+ text-align: center;
+}
+
+.logo {
+ height: 6em;
+ padding: 1.5em;
+ will-change: filter;
+}
+.logo:hover {
+ filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.vanilla:hover {
+ filter: drop-shadow(0 0 2em #3178c6aa);
+}
+
+.card {
+ padding: 2em;
+}
+
+.read-the-docs {
+ color: #888;
+}
+
+button {
+ border-radius: 8px;
+ border: 1px solid transparent;
+ padding: 0.6em 1.2em;
+ font-size: 1em;
+ font-weight: 500;
+ font-family: inherit;
+ background-color: #1a1a1a;
+ cursor: pointer;
+ transition: border-color 0.25s;
+}
+button:hover {
+ border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+ outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+ :root {
+ color: #213547;
+ background-color: #ffffff;
+ }
+ a:hover {
+ color: #747bff;
+ }
+ button {
+ background-color: #f9f9f9;
+ }
+}
diff --git a/MiniIndex/ClientApp/src/styles/button-styles.js b/MiniIndex/ClientApp/src/styles/button-styles.js
new file mode 100644
index 0000000..fbf2267
--- /dev/null
+++ b/MiniIndex/ClientApp/src/styles/button-styles.js
@@ -0,0 +1,74 @@
+import { css } from "lit";
+
+export const buttonStyles = css`
+ .style-primary-border,
+ .btn-primary {
+ color: #fff;
+ background-color: var(--app-primary-color);
+ border-color: var(--app-secondary-color);
+ }
+
+ .style-secondary-border,
+ .btn-secondary {
+ color: #000;
+ background-color: var(--app-secondary-color);
+ border-color: var(--app-primary-color);
+ }
+
+ .style-primary {
+ color: #fff;
+ background-color: var(--app-primary-color);
+ }
+
+ .style-secondary {
+ color: #000;
+ background-color: var(--app-secondary-color);
+ }
+
+ .style-danger {
+ background-color: darkred !important;
+ color: white;
+ }
+
+ .style-moderator {
+ background-color: #fff7b9 !important;
+ }
+
+ .style-dull {
+ background-color: gray !important;
+ color: black !important;
+ }
+
+ .style-green {
+ background-color: darkgreen !important;
+ color: white !important;
+ }
+
+ /* Buttons */
+ .btn {
+ font-weight: bolder;
+ display: inline-block;
+ text-align: center;
+ white-space: nowrap;
+ vertical-align: middle;
+ user-select: none;
+ border: 1px solid transparent;
+ padding: 0.5rem !important;
+ border-radius: 0.25rem;
+ margin: 4px;
+ text-decoration: none;
+ }
+
+ .btn:disabled {
+ background-color: gray;
+ opacity: 100% !important;
+ }
+
+ .btn:hover {
+ opacity: 50%;
+ }
+
+ .btn-block {
+ width: 100%;
+ }
+`;
diff --git a/MiniIndex/ClientApp/src/styles/font-styles.js b/MiniIndex/ClientApp/src/styles/font-styles.js
new file mode 100644
index 0000000..b6246c7
--- /dev/null
+++ b/MiniIndex/ClientApp/src/styles/font-styles.js
@@ -0,0 +1,34 @@
+import { css } from "lit";
+
+//TODO: Figure out how to make global?
+export const fontStyles = css`
+ h3 {
+ font-size: 1.25em;
+ line-height: 1em;
+ white-space: normal;
+ }
+
+ h4 {
+ font-size: 0.8em;
+ }
+
+ h1,
+ h2,
+ h3,
+ h4 {
+ font-family: "Montserrat", sans-serif !important;
+ font-weight: 500;
+ }
+
+ .montserrat {
+ font-family: "Montserrat", sans-serif !important;
+ }
+
+ .btn {
+ font-family: "Montserrat", sans-serif !important;
+ }
+
+ input.full-width {
+ font-family: "Montserrat", sans-serif !important;
+ }
+`;
diff --git a/MiniIndex/ClientApp/src/styles/global.css b/MiniIndex/ClientApp/src/styles/global.css
new file mode 100644
index 0000000..e69de29
diff --git a/MiniIndex/ClientApp/src/styles/icon-styles.js b/MiniIndex/ClientApp/src/styles/icon-styles.js
new file mode 100644
index 0000000..57e0783
--- /dev/null
+++ b/MiniIndex/ClientApp/src/styles/icon-styles.js
@@ -0,0 +1,35 @@
+import { css } from "lit";
+
+//TODO: Refactor into components
+export const iconStyles = css`
+ .icon-container {
+ border-style: solid;
+ border-width: 2px;
+ border-color: var(--app-secondary-color);
+ border-radius: 4px;
+ padding: 5px;
+ }
+
+ .icon {
+ filter: invert(97%) sepia(7%) saturate(488%) hue-rotate(108deg)
+ brightness(91%) contrast(96%);
+ height: 28px;
+ width: 28px;
+ }
+
+ .icon-heart {
+ background-image: url("../images/IconFont/heart.svg");
+ }
+
+ .icon-menu {
+ background-image: url("../images/IconFont/bars.svg");
+ }
+
+ .icon-random {
+ background-image: url("../images/IconFont/random.svg");
+ }
+
+ .icon-profile {
+ background-image: url("../images/IconFont/user-circle.svg");
+ }
+`;
diff --git a/MiniIndex/ClientApp/src/styles/layout-styles.js b/MiniIndex/ClientApp/src/styles/layout-styles.js
new file mode 100644
index 0000000..1a784fc
--- /dev/null
+++ b/MiniIndex/ClientApp/src/styles/layout-styles.js
@@ -0,0 +1,128 @@
+import { css } from "lit";
+
+//TODO: Refactor some of these into components.
+export const centerStyles = css`
+ .center {
+ box-sizing: content-box;
+ margin-left: auto;
+ margin-right: auto;
+ max-width: 100%;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ }
+
+ .center-t {
+ box-sizing: content-box;
+ margin-left: auto;
+ margin-right: auto;
+ text-align: center;
+ max-width: 100%;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ }
+`;
+
+export const gridStyles = css`
+ .grid {
+ display: grid;
+ grid-gap: 1rem;
+ }
+
+ @supports (width: min(250px, 100%)) {
+ .grid {
+ grid-template-columns: repeat(auto-fit, minmax(min(250px, 100%), 1fr));
+ }
+ }
+`;
+
+export const miniListStyles = css`
+ :host {
+ display: block;
+ }
+
+ ul {
+ list-style-type: none;
+ padding: 0;
+ margin: 0;
+ }
+
+ li {
+ text-dcoration: none;
+ }
+
+ .grid {
+ display: grid;
+ grid-gap: 1rem;
+ }
+
+ @supports (width: min(250px, 100%)) {
+ .grid {
+ grid-template-columns: repeat(auto-fit, minmax(min(250px, 100%), 1fr));
+ }
+ }
+`;
+
+export const rowStyles = css`
+ .row {
+ display: flex;
+ flex-direction: row;
+ max-width: 100%;
+ }
+`;
+
+export const sidebarStyles = css`
+ .with-sidebar {
+ display: flex;
+ flex-wrap: wrap;
+ gap: var(--s1);
+ }
+
+ .with-sidebar > :first-child {
+ flex-basis: 250px;
+ flex-grow: 1;
+ }
+
+ .with-sidebar > :last-child {
+ flex-basis: 0;
+ flex-grow: 999;
+ min-width: 50%;
+ }
+`;
+
+export const stackStyles = css`
+ .stack {
+ display: flex;
+ flex-direction: column;
+ justify-content: flex-start;
+ max-width: 100%;
+ }
+
+ .stack > * {
+ margin-top: 0;
+ margin-bottom: 0;
+ }
+
+ .stack > * + * {
+ margin-top: var(--space, 1.5rem);
+ }
+`;
+
+export const switcherStyles = css`
+ .switcher {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 1rem;
+ }
+
+ .switcher > * {
+ flex-grow: 1;
+ flex-basis: calc((40rem - 100%) * 999);
+ }
+
+ .switcher > :nth-last-child(n + 5),
+ .switcher > :nth-last-child(n + 5) ~ * {
+ flex-basis: 100%;
+ }
+`;
diff --git a/MiniIndex/ClientApp/src/typescript.svg b/MiniIndex/ClientApp/src/typescript.svg
new file mode 100644
index 0000000..d91c910
--- /dev/null
+++ b/MiniIndex/ClientApp/src/typescript.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/MiniIndex/ClientApp/src/utils/AuthorizeService.js b/MiniIndex/ClientApp/src/utils/AuthorizeService.js
new file mode 100644
index 0000000..88f89bb
--- /dev/null
+++ b/MiniIndex/ClientApp/src/utils/AuthorizeService.js
@@ -0,0 +1,270 @@
+//Scaffolded from .NET's JWT React Sample
+import { UserManager, WebStorageStateStore } from "oidc-client";
+import { perfMark, perfMeasure, logError } from "./PerformanceMarks";
+
+export class AuthorizeService {
+ _callbacks = [];
+ _nextSubscriptionId = 0;
+ _user = null;
+ _isAuthenticated = false;
+
+ // By default pop ups are disabled because they don't work properly on Edge.
+ // If you want to enable pop up authentication simply set this flag to false.
+ _popUpDisabled = true;
+
+ async isAuthenticated() {
+ const user = await this.getUser();
+ return !!user;
+ }
+
+ async getUser() {
+ perfMark("tmi-getUser-start");
+ if (this._user && this._user.profile) {
+ perfMark("tmi-getUser-end");
+ perfMeasure("tmi-getUser-fast", "tmi-getUser-start", "tmi-getUser-end");
+ return this._user.profile;
+ }
+
+ await this.ensureUserManagerInitialized();
+ const user = await this.userManager.getUser();
+ perfMark("tmi-getUser-end");
+ perfMeasure("tmi-getUser-slow", "tmi-getUser-start", "tmi-getUser-end");
+ return user && user.profile;
+ }
+
+ async getAccessToken() {
+ perfMark("tmi-getAccessToken-start");
+ await this.ensureUserManagerInitialized();
+ const user = await this.userManager.getUser();
+ perfMark("tmi-getAccessToken-end");
+ perfMeasure(
+ "tmi-getAccessToken",
+ "tmi-getAccessToken-start",
+ "tmi-getAccessToken-end"
+ );
+ return user && user.access_token;
+ }
+
+ // We try to authenticate the user in three different ways:
+ // 1) We try to see if we can authenticate the user silently. This happens
+ // when the user is already logged in on the IdP and is done using a hidden iframe
+ // on the client.
+ // 2) We try to authenticate the user using a PopUp Window. This might fail if there is a
+ // Pop-Up blocker or the user has disabled PopUps.
+ // 3) If the two methods above fail, we redirect the browser to the IdP to perform a traditional
+ // redirect flow.
+ async signIn(state) {
+ perfMark("tmi-signin-start");
+ await this.ensureUserManagerInitialized();
+ try {
+ const silentUser = await this.userManager.signinSilent(
+ this.createArguments()
+ );
+ this.updateState(silentUser);
+ perfMark("tmi-signin-end-silent");
+ perfMeasure(
+ "tmi-signin-silent",
+ "tmi-signin-start",
+ "tmi-signin-end-silent"
+ );
+ return this.success(state);
+ } catch (silentError) {
+ // User might not be authenticated, fallback to popup authentication
+ logError("Silent authentication error: ", silentError);
+
+ try {
+ if (this._popUpDisabled) {
+ throw new Error(
+ "Popup disabled. Change 'AuthorizeService.js:AuthorizeService._popupDisabled' to false to enable it."
+ );
+ }
+
+ const popUpUser = await this.userManager.signinPopup(
+ this.createArguments()
+ );
+ this.updateState(popUpUser);
+ perfMark("tmi-signin-end-popup");
+ perfMeasure(
+ "tmi-signin-popup",
+ "tmi-signin-start",
+ "tmi-signin-end-popup"
+ );
+ return this.success(state);
+ } catch (popUpError) {
+ if (popUpError.message === "Popup window closed") {
+ // The user explicitly cancelled the login action by closing an opened popup.
+ return this.error("The user closed the window.");
+ } else if (!this._popUpDisabled) {
+ logError("Popup authentication error: ", popUpError);
+ }
+
+ // PopUps might be blocked by the user, fallback to redirect
+ try {
+ await this.userManager.signinRedirect(this.createArguments(state));
+ perfMark("tmi-signin-end-redirect");
+ perfMeasure(
+ "tmi-signin-redirect",
+ "tmi-signin-start",
+ "tmi-signin-end-redirect"
+ );
+ return this.redirect();
+ } catch (redirectError) {
+ logError("Redirect authentication error: ", redirectError);
+ perfMark("tmi-signin-end-error");
+ perfMeasure(
+ "tmi-signin-error",
+ "tmi-signin-start",
+ "tmi-signin-end-error"
+ );
+ return this.error(redirectError);
+ }
+ }
+ }
+ }
+
+ async completeSignIn(url) {
+ try {
+ await this.ensureUserManagerInitialized();
+ const user = await this.userManager.signinCallback(url);
+ this.updateState(user);
+ return this.success(user && user.state);
+ } catch (error) {
+ logError("There was an error signing in: ", error);
+ return this.error("There was an error signing in.");
+ }
+ }
+
+ // We try to sign out the user in two different ways:
+ // 1) We try to do a sign-out using a PopUp Window. This might fail if there is a
+ // Pop-Up blocker or the user has disabled PopUps.
+ // 2) If the method above fails, we redirect the browser to the IdP to perform a traditional
+ // post logout redirect flow.
+ async signOut(state) {
+ await this.ensureUserManagerInitialized();
+ try {
+ if (this._popUpDisabled) {
+ throw new Error(
+ "Popup disabled. Change 'AuthorizeService.js:AuthorizeService._popupDisabled' to false to enable it."
+ );
+ }
+
+ await this.userManager.signoutPopup(this.createArguments());
+ this.updateState(undefined);
+ return this.success(state);
+ } catch (popupSignOutError) {
+ logError("Popup signout error: ", popupSignOutError);
+ try {
+ await this.userManager.signoutRedirect(this.createArguments(state));
+ return this.redirect();
+ } catch (redirectSignOutError) {
+ logError("Redirect signout error: ", redirectSignOutError);
+ return this.error(redirectSignOutError);
+ }
+ }
+ }
+
+ async completeSignOut(url) {
+ await this.ensureUserManagerInitialized();
+ try {
+ const response = await this.userManager.signoutCallback(url);
+ this.updateState(null);
+ return this.success(response && response.data);
+ } catch (error) {
+ logError(`There was an error trying to log out '${error}'.`);
+ return this.error(error);
+ }
+ }
+
+ updateState(user) {
+ this._user = user;
+ this._isAuthenticated = !!this._user;
+ this.notifySubscribers();
+ }
+
+ subscribe(callback) {
+ this._callbacks.push({
+ callback,
+ subscription: this._nextSubscriptionId++,
+ });
+ return this._nextSubscriptionId - 1;
+ }
+
+ unsubscribe(subscriptionId) {
+ const subscriptionIndex = this._callbacks
+ .map((element, index) =>
+ element.subscription === subscriptionId
+ ? { found: true, index }
+ : { found: false }
+ )
+ .filter((element) => element.found === true);
+ if (subscriptionIndex.length !== 1) {
+ throw new Error(
+ `Found an invalid number of subscriptions ${subscriptionIndex.length}`
+ );
+ }
+
+ this._callbacks.splice(subscriptionIndex[0].index, 1);
+ }
+
+ notifySubscribers() {
+ for (let i = 0; i < this._callbacks.length; i++) {
+ const callback = this._callbacks[i].callback;
+ callback();
+ }
+ }
+
+ createArguments(state) {
+ return { useReplaceToNavigate: true, data: state };
+ }
+
+ error(message) {
+ return { status: AuthenticationResultStatus.Fail, message };
+ }
+
+ success(state) {
+ return { status: AuthenticationResultStatus.Success, state };
+ }
+
+ redirect() {
+ return { status: AuthenticationResultStatus.Redirect };
+ }
+
+ async ensureUserManagerInitialized() {
+ if (this.userManager !== undefined) {
+ return;
+ }
+
+ let response = await fetch("/_configuration/DotNetJWTTest");
+ if (!response.ok) {
+ throw new Error(`Could not load settings for 'DotNetJWTTest'`);
+ }
+
+ let settings = await response.json();
+ settings.automaticSilentRenew = true;
+ settings.includeIdTokenInSilentRenew = true;
+ settings.userStore = new WebStorageStateStore({
+ prefix: "DotNetJWTTest",
+ });
+
+ this.userManager = new UserManager(settings);
+
+ this.userManager.events.addUserSignedOut(async () => {
+ await this.userManager.removeUser();
+ this.updateState(undefined);
+ });
+ }
+
+ static get instance() {
+ return authService;
+ }
+}
+
+const authService = new AuthorizeService();
+
+export default authService;
+
+export const AuthenticationResultStatus = {
+ Redirect: "redirect",
+ Success: "success",
+ Fail: "fail",
+};
diff --git a/MiniIndex/ClientApp/src/utils/PerformanceMarks.ts b/MiniIndex/ClientApp/src/utils/PerformanceMarks.ts
new file mode 100644
index 0000000..bc21191
--- /dev/null
+++ b/MiniIndex/ClientApp/src/utils/PerformanceMarks.ts
@@ -0,0 +1,19 @@
+export function perfMark(markName: string) {
+ performance.mark(markName);
+}
+
+export function perfMeasure(
+ measureName: string,
+ startMark: string,
+ endMark: string
+) {
+ performance.measure(measureName, startMark, endMark);
+}
+
+export function logError(errorDetails: string) {
+ console.error(errorDetails);
+}
+
+export function logMsg(text: string) {
+ console.log(text);
+}
diff --git a/MiniIndex/ClientApp/src/utils/minis.ts b/MiniIndex/ClientApp/src/utils/minis.ts
new file mode 100644
index 0000000..73df97e
--- /dev/null
+++ b/MiniIndex/ClientApp/src/utils/minis.ts
@@ -0,0 +1,107 @@
+import authService from "../utils/AuthorizeService.js";
+import { perfMark, perfMeasure } from "../utils/PerformanceMarks";
+
+export async function getMinis(): Promise
+
`
+ : html`Not found`}
+ + ${this._data.Name} by + ${this._data.Creator.Name} +
+ +
+ ${
+ //TOOD: Do this.
+ this._data.Sources && this._data.Sources.length > 0
+ ? this._data.Sources.map((source) => {
+ return html`View On @miniSource.Site.SiteName`;
+ })
+ : html`View at source`
+ }
+
+
+ ${this._isFavorite
+ ? "Remove from Favorites"
+ : "Add to Favorites"}
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ ${this._data.MiniTags.map((tag) => {
+ return tag.Status == 1
+ ? html`
+ ${tag.Tag.Category
+ ? html`${TagCategory[tag.Tag.Category]}:`
+ : ""}
+ ${tag.Tag.TagName}
+ `
+ : null;
+ })}
+ Tags
+ + Something look wrong? + + +
-
-
-
-
-
\ No newline at end of file
diff --git a/MiniIndex/Pages/Index.cshtml.cs b/MiniIndex/Pages/Index.cshtml.cs
deleted file mode 100644
index f91b998..0000000
--- a/MiniIndex/Pages/Index.cshtml.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using Microsoft.AspNetCore.Mvc.RazorPages;
-using Microsoft.EntityFrameworkCore;
-using MiniIndex.Models;
-using MiniIndex.Persistence;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace MiniIndex.Pages
-{
- public class IndexModel : PageModel
- {
- public IndexModel(MiniIndexContext context)
- {
- _context = context;
- MiniCount = 0;
- UntaggedMiniCount = 0;
- }
-
- private readonly MiniIndexContext _context;
-
- public int MiniCount { get; set; }
- public int UntaggedMiniCount { get; set; }
- public List
-
- Welcome to The Mini Index!
- -- This is a crowd-sourced index of 3d printable files for minis, terrain tiles, and scatter terrain across - different websites for use with tabletop games like Dungeons and Dragons. - We have @Model.MiniCount.ToString("N0") models tagged with the important attributes of the mini in order to make it fast and easy to find exactly what you're looking for. -
- - - - -
-
- What's new
--
-
- NewPretty much every page has been re-designed to be faster, better, and easier for us to improve in the future! -
- WarningYou may need to "hard" refresh by pressing Ctrl+Shift+R (Windows) or Cmd+Shift+R (Mac) to get some pages to look right. -
- NewSearch results can now be ordered by relevancy or most recent. -
- Bug FixAutomatically added tags will now be removed from the "Add Tags" list. - - - - -
+
+
+ TODO
+
+
+
+
+
+
+
+>
diff --git a/MiniIndex/wwwroot/package.json b/MiniIndex/wwwroot/package.json
new file mode 100644
index 0000000..18c2039
--- /dev/null
+++ b/MiniIndex/wwwroot/package.json
@@ -0,0 +1,11 @@
+{
+ "dependencies": {
+ "oidc-client": "^1.11.5"
+ },
+ "devDependencies": {
+ "@web/dev-server": "^0.1.22"
+ },
+ "scripts": {
+ "start": "web-dev-server --port 3000 --node-resolve --watch --open"
+ }
+}
diff --git a/MiniIndex/wwwroot/templatejs/ApiAuthorizationConstants.js b/MiniIndex/wwwroot/templatejs/ApiAuthorizationConstants.js
new file mode 100644
index 0000000..d246a30
--- /dev/null
+++ b/MiniIndex/wwwroot/templatejs/ApiAuthorizationConstants.js
@@ -0,0 +1,38 @@
+export const ApplicationName = 'DotNetJWTTest';
+
+export const QueryParameterNames = {
+ ReturnUrl: 'returnUrl',
+ Message: 'message'
+};
+
+export const LogoutActions = {
+ LogoutCallback: 'logout-callback',
+ Logout: 'logout',
+ LoggedOut: 'logged-out'
+};
+
+export const LoginActions = {
+ Login: 'login',
+ LoginCallback: 'login-callback',
+ LoginFailed: 'login-failed',
+ Profile: 'profile',
+ Register: 'register'
+};
+
+const prefix = '/authentication';
+
+export const ApplicationPaths = {
+ DefaultLoginRedirectPath: '/',
+ ApiAuthorizationClientConfigurationUrl: `_configuration/${ApplicationName}`,
+ ApiAuthorizationPrefix: prefix,
+ Login: `${prefix}/${LoginActions.Login}`,
+ LoginFailed: `${prefix}/${LoginActions.LoginFailed}`,
+ LoginCallback: `${prefix}/${LoginActions.LoginCallback}`,
+ Register: `${prefix}/${LoginActions.Register}`,
+ Profile: `${prefix}/${LoginActions.Profile}`,
+ LogOut: `${prefix}/${LogoutActions.Logout}`,
+ LoggedOut: `${prefix}/${LogoutActions.LoggedOut}`,
+ LogOutCallback: `${prefix}/${LogoutActions.LogoutCallback}`,
+ IdentityRegisterPath: 'Identity/Account/Register',
+ IdentityManagePath: 'Identity/Account/Manage'
+};
diff --git a/MiniIndex/wwwroot/templatejs/ApiAuthorizationRoutes.js b/MiniIndex/wwwroot/templatejs/ApiAuthorizationRoutes.js
new file mode 100644
index 0000000..6de40a4
--- /dev/null
+++ b/MiniIndex/wwwroot/templatejs/ApiAuthorizationRoutes.js
@@ -0,0 +1,49 @@
+import React from 'react';
+import { Login } from './Login'
+import { Logout } from './Logout'
+import { ApplicationPaths, LoginActions, LogoutActions } from './ApiAuthorizationConstants';
+
+const ApiAuthorizationRoutes = [
+ {
+ path: ApplicationPaths.Login,
+ element: loginAction(LoginActions.Login)
+ },
+ {
+ path: ApplicationPaths.LoginFailed,
+ element: loginAction(LoginActions.LoginFailed)
+ },
+ {
+ path: ApplicationPaths.LoginCallback,
+ element: loginAction(LoginActions.LoginCallback)
+ },
+ {
+ path: ApplicationPaths.Profile,
+ element: loginAction(LoginActions.Profile)
+ },
+ {
+ path: ApplicationPaths.Register,
+ element: loginAction(LoginActions.Register)
+ },
+ {
+ path: ApplicationPaths.LogOut,
+ element: logoutAction(LogoutActions.Logout)
+ },
+ {
+ path: ApplicationPaths.LogOutCallback,
+ element: logoutAction(LogoutActions.LogoutCallback)
+ },
+ {
+ path: ApplicationPaths.LoggedOut,
+ element: logoutAction(LogoutActions.LoggedOut)
+ }
+];
+
+function loginAction(name){
+ return {message}
+ } else {
+ switch (action) {
+ case LoginActions.Login:
+ return (Processing login
);
+ case LoginActions.LoginCallback:
+ return (Processing login callback
);
+ case LoginActions.Profile:
+ case LoginActions.Register:
+ return ();
+ default:
+ throw new Error(`Invalid action '${action}'`);
+ }
+ }
+ }
+
+ async login(returnUrl) {
+ const state = { returnUrl };
+ const result = await authService.signIn(state);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ break;
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(returnUrl);
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.setState({ message: result.message });
+ break;
+ default:
+ throw new Error(`Invalid status result ${result.status}.`);
+ }
+ }
+
+ async processLoginCallback() {
+ const url = window.location.href;
+ const result = await authService.completeSignIn(url);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ // There should not be any redirects as the only time completeSignIn finishes
+ // is when we are doing a redirect sign in flow.
+ throw new Error('Should not redirect.');
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(this.getReturnUrl(result.state));
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.setState({ message: result.message });
+ break;
+ default:
+ throw new Error(`Invalid authentication result status '${result.status}'.`);
+ }
+ }
+
+ getReturnUrl(state) {
+ const params = new URLSearchParams(window.location.search);
+ const fromQuery = params.get(QueryParameterNames.ReturnUrl);
+ if (fromQuery && !fromQuery.startsWith(`${window.location.origin}/`)) {
+ // This is an extra check to prevent open redirects.
+ throw new Error("Invalid return url. The return url needs to have the same origin as the current page.")
+ }
+ return (state && state.returnUrl) || fromQuery || `${window.location.origin}/`;
+ }
+
+ redirectToRegister() {
+ this.redirectToApiAuthorizationPath(`${ApplicationPaths.IdentityRegisterPath}?${QueryParameterNames.ReturnUrl}=${encodeURI(ApplicationPaths.Login)}`);
+ }
+
+ redirectToProfile() {
+ this.redirectToApiAuthorizationPath(ApplicationPaths.IdentityManagePath);
+ }
+
+ redirectToApiAuthorizationPath(apiAuthorizationPath) {
+ const redirectUrl = `${window.location.origin}/${apiAuthorizationPath}`;
+ // It's important that we do a replace here so that when the user hits the back arrow on the
+ // browser they get sent back to where it was on the app instead of to an endpoint on this
+ // component.
+ window.location.replace(redirectUrl);
+ }
+
+ navigateToReturnUrl(returnUrl) {
+ // It's important that we do a replace here so that we remove the callback uri with the
+ // fragment containing the tokens from the browser history.
+ window.location.replace(returnUrl);
+ }
+}
diff --git a/MiniIndex/wwwroot/templatejs/LoginMenu.js b/MiniIndex/wwwroot/templatejs/LoginMenu.js
new file mode 100644
index 0000000..aa0d696
--- /dev/null
+++ b/MiniIndex/wwwroot/templatejs/LoginMenu.js
@@ -0,0 +1,69 @@
+import React, { Component, Fragment } from 'react';
+import { NavItem, NavLink } from 'reactstrap';
+import { Link } from 'react-router-dom';
+import authService from './AuthorizeService';
+import { ApplicationPaths } from './ApiAuthorizationConstants';
+
+export class LoginMenu extends Component {
+ constructor(props) {
+ super(props);
+
+ this.state = {
+ isAuthenticated: false,
+ userName: null
+ };
+ }
+
+ componentDidMount() {
+ this._subscription = authService.subscribe(() => this.populateState());
+ this.populateState();
+ }
+
+ componentWillUnmount() {
+ authService.unsubscribe(this._subscription);
+ }
+
+ async populateState() {
+ const [isAuthenticated, user] = await Promise.all([authService.isAuthenticated(), authService.getUser()])
+ this.setState({
+ isAuthenticated,
+ userName: user && user.name
+ });
+ }
+
+ render() {
+ const { isAuthenticated, userName } = this.state;
+ if (!isAuthenticated) {
+ const registerPath = `${ApplicationPaths.Register}`;
+ const loginPath = `${ApplicationPaths.Login}`;
+ return this.anonymousView(registerPath, loginPath);
+ } else {
+ const profilePath = `${ApplicationPaths.Profile}`;
+ const logoutPath = `${ApplicationPaths.LogOut}`;
+ const logoutState = { local: true };
+ return this.authenticatedView(userName, profilePath, logoutPath, logoutState);
+ }
+ }
+
+ authenticatedView(userName, profilePath, logoutPath, logoutState) {
+ return ({message}
);
+ } else {
+ const action = this.props.action;
+ switch (action) {
+ case LogoutActions.Logout:
+ return (Processing logout
);
+ case LogoutActions.LogoutCallback:
+ return (Processing logout callback
);
+ case LogoutActions.LoggedOut:
+ return ({message}
);
+ default:
+ throw new Error(`Invalid action '${action}'`);
+ }
+ }
+ }
+
+ async logout(returnUrl) {
+ const state = { returnUrl };
+ const isauthenticated = await authService.isAuthenticated();
+ if (isauthenticated) {
+ const result = await authService.signOut(state);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ break;
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(returnUrl);
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.setState({ message: result.message });
+ break;
+ default:
+ throw new Error("Invalid authentication result status.");
+ }
+ } else {
+ this.setState({ message: "You successfully logged out!" });
+ }
+ }
+
+ async processLogoutCallback() {
+ const url = window.location.href;
+ const result = await authService.completeSignOut(url);
+ switch (result.status) {
+ case AuthenticationResultStatus.Redirect:
+ // There should not be any redirects as the only time completeAuthentication finishes
+ // is when we are doing a redirect sign in flow.
+ throw new Error('Should not redirect.');
+ case AuthenticationResultStatus.Success:
+ await this.navigateToReturnUrl(this.getReturnUrl(result.state));
+ break;
+ case AuthenticationResultStatus.Fail:
+ this.setState({ message: result.message });
+ break;
+ default:
+ throw new Error("Invalid authentication result status.");
+ }
+ }
+
+ async populateAuthenticationState() {
+ const authenticated = await authService.isAuthenticated();
+ this.setState({ isReady: true, authenticated });
+ }
+
+ getReturnUrl(state) {
+ const params = new URLSearchParams(window.location.search);
+ const fromQuery = params.get(QueryParameterNames.ReturnUrl);
+ if (fromQuery && !fromQuery.startsWith(`${window.location.origin}/`)) {
+ // This is an extra check to prevent open redirects.
+ throw new Error("Invalid return url. The return url needs to have the same origin as the current page.")
+ }
+ return (state && state.returnUrl) ||
+ fromQuery ||
+ `${window.location.origin}${ApplicationPaths.LoggedOut}`;
+ }
+
+ navigateToReturnUrl(returnUrl) {
+ return window.location.replace(returnUrl);
+ }
+}
diff --git a/MiniIndex/wwwroot/templatejs/oidc-client.js b/MiniIndex/wwwroot/templatejs/oidc-client.js
new file mode 100644
index 0000000..be3c1c2
--- /dev/null
+++ b/MiniIndex/wwwroot/templatejs/oidc-client.js
@@ -0,0 +1,24396 @@
+var Oidc =
+/******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./index.js":
+/*!******************!*\
+ !*** ./index.js ***!
+ \******************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _Log = __webpack_require__(/*! ./src/Log.js */ "./src/Log.js");
+
+var _OidcClient = __webpack_require__(/*! ./src/OidcClient.js */ "./src/OidcClient.js");
+
+var _OidcClientSettings = __webpack_require__(/*! ./src/OidcClientSettings.js */ "./src/OidcClientSettings.js");
+
+var _WebStorageStateStore = __webpack_require__(/*! ./src/WebStorageStateStore.js */ "./src/WebStorageStateStore.js");
+
+var _InMemoryWebStorage = __webpack_require__(/*! ./src/InMemoryWebStorage.js */ "./src/InMemoryWebStorage.js");
+
+var _UserManager = __webpack_require__(/*! ./src/UserManager.js */ "./src/UserManager.js");
+
+var _AccessTokenEvents = __webpack_require__(/*! ./src/AccessTokenEvents.js */ "./src/AccessTokenEvents.js");
+
+var _MetadataService = __webpack_require__(/*! ./src/MetadataService.js */ "./src/MetadataService.js");
+
+var _CordovaPopupNavigator = __webpack_require__(/*! ./src/CordovaPopupNavigator.js */ "./src/CordovaPopupNavigator.js");
+
+var _CordovaIFrameNavigator = __webpack_require__(/*! ./src/CordovaIFrameNavigator.js */ "./src/CordovaIFrameNavigator.js");
+
+var _CheckSessionIFrame = __webpack_require__(/*! ./src/CheckSessionIFrame.js */ "./src/CheckSessionIFrame.js");
+
+var _TokenRevocationClient = __webpack_require__(/*! ./src/TokenRevocationClient.js */ "./src/TokenRevocationClient.js");
+
+var _SessionMonitor = __webpack_require__(/*! ./src/SessionMonitor.js */ "./src/SessionMonitor.js");
+
+var _Global = __webpack_require__(/*! ./src/Global.js */ "./src/Global.js");
+
+var _User = __webpack_require__(/*! ./src/User.js */ "./src/User.js");
+
+var _version = __webpack_require__(/*! ./version.js */ "./version.js");
+
+// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+exports.default = {
+ Version: _version.Version,
+ Log: _Log.Log,
+ OidcClient: _OidcClient.OidcClient,
+ OidcClientSettings: _OidcClientSettings.OidcClientSettings,
+ WebStorageStateStore: _WebStorageStateStore.WebStorageStateStore,
+ InMemoryWebStorage: _InMemoryWebStorage.InMemoryWebStorage,
+ UserManager: _UserManager.UserManager,
+ AccessTokenEvents: _AccessTokenEvents.AccessTokenEvents,
+ MetadataService: _MetadataService.MetadataService,
+ CordovaPopupNavigator: _CordovaPopupNavigator.CordovaPopupNavigator,
+ CordovaIFrameNavigator: _CordovaIFrameNavigator.CordovaIFrameNavigator,
+ CheckSessionIFrame: _CheckSessionIFrame.CheckSessionIFrame,
+ TokenRevocationClient: _TokenRevocationClient.TokenRevocationClient,
+ SessionMonitor: _SessionMonitor.SessionMonitor,
+ Global: _Global.Global,
+ User: _User.User
+};
+module.exports = exports['default'];
+
+/***/ }),
+
+/***/ "./jsrsasign/dist/jsrsasign.js":
+/*!*************************************!*\
+ !*** ./jsrsasign/dist/jsrsasign.js ***!
+ \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(Buffer) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+/*
+ * jsrsasign(all) 8.0.12 (2018-04-22) (c) 2010-2018 Kenji Urushima | kjur.github.com/jsrsasign/license
+ */
+
+var navigator = {};
+navigator.userAgent = false;
+
+var window = {};
+
+/*! CryptoJS v3.1.2 core-fix.js
+ * code.google.com/p/crypto-js
+ * (c) 2009-2013 by Jeff Mott. All rights reserved.
+ * code.google.com/p/crypto-js/wiki/License
+ * THIS IS FIX of 'core.js' to fix Hmac issue.
+ * https://code.google.com/p/crypto-js/issues/detail?id=84
+ * https://crypto-js.googlecode.com/svn-history/r667/branches/3.x/src/core.js
+ */
+var CryptoJS = CryptoJS || function (e, g) {
+ var a = {};var b = a.lib = {};var j = b.Base = function () {
+ function n() {}return { extend: function extend(p) {
+ n.prototype = this;var o = new n();if (p) {
+ o.mixIn(p);
+ }if (!o.hasOwnProperty("init")) {
+ o.init = function () {
+ o.$super.init.apply(this, arguments);
+ };
+ }o.init.prototype = o;o.$super = this;return o;
+ }, create: function create() {
+ var o = this.extend();o.init.apply(o, arguments);return o;
+ }, init: function init() {}, mixIn: function mixIn(p) {
+ for (var o in p) {
+ if (p.hasOwnProperty(o)) {
+ this[o] = p[o];
+ }
+ }if (p.hasOwnProperty("toString")) {
+ this.toString = p.toString;
+ }
+ }, clone: function clone() {
+ return this.init.prototype.extend(this);
+ } };
+ }();var l = b.WordArray = j.extend({ init: function init(o, n) {
+ o = this.words = o || [];if (n != g) {
+ this.sigBytes = n;
+ } else {
+ this.sigBytes = o.length * 4;
+ }
+ }, toString: function toString(n) {
+ return (n || h).stringify(this);
+ }, concat: function concat(t) {
+ var q = this.words;var p = t.words;var n = this.sigBytes;var s = t.sigBytes;this.clamp();if (n % 4) {
+ for (var r = 0; r < s; r++) {
+ var o = p[r >>> 2] >>> 24 - r % 4 * 8 & 255;q[n + r >>> 2] |= o << 24 - (n + r) % 4 * 8;
+ }
+ } else {
+ for (var r = 0; r < s; r += 4) {
+ q[n + r >>> 2] = p[r >>> 2];
+ }
+ }this.sigBytes += s;return this;
+ }, clamp: function clamp() {
+ var o = this.words;var n = this.sigBytes;o[n >>> 2] &= 4294967295 << 32 - n % 4 * 8;o.length = e.ceil(n / 4);
+ }, clone: function clone() {
+ var n = j.clone.call(this);n.words = this.words.slice(0);return n;
+ }, random: function random(p) {
+ var o = [];for (var n = 0; n < p; n += 4) {
+ o.push(e.random() * 4294967296 | 0);
+ }return new l.init(o, p);
+ } });var m = a.enc = {};var h = m.Hex = { stringify: function stringify(p) {
+ var r = p.words;var o = p.sigBytes;var q = [];for (var n = 0; n < o; n++) {
+ var s = r[n >>> 2] >>> 24 - n % 4 * 8 & 255;q.push((s >>> 4).toString(16));q.push((s & 15).toString(16));
+ }return q.join("");
+ }, parse: function parse(p) {
+ var n = p.length;var q = [];for (var o = 0; o < n; o += 2) {
+ q[o >>> 3] |= parseInt(p.substr(o, 2), 16) << 24 - o % 8 * 4;
+ }return new l.init(q, n / 2);
+ } };var d = m.Latin1 = { stringify: function stringify(q) {
+ var r = q.words;var p = q.sigBytes;var n = [];for (var o = 0; o < p; o++) {
+ var s = r[o >>> 2] >>> 24 - o % 4 * 8 & 255;n.push(String.fromCharCode(s));
+ }return n.join("");
+ }, parse: function parse(p) {
+ var n = p.length;var q = [];for (var o = 0; o < n; o++) {
+ q[o >>> 2] |= (p.charCodeAt(o) & 255) << 24 - o % 4 * 8;
+ }return new l.init(q, n);
+ } };var c = m.Utf8 = { stringify: function stringify(n) {
+ try {
+ return decodeURIComponent(escape(d.stringify(n)));
+ } catch (o) {
+ throw new Error("Malformed UTF-8 data");
+ }
+ }, parse: function parse(n) {
+ return d.parse(unescape(encodeURIComponent(n)));
+ } };var i = b.BufferedBlockAlgorithm = j.extend({ reset: function reset() {
+ this._data = new l.init();this._nDataBytes = 0;
+ }, _append: function _append(n) {
+ if (typeof n == "string") {
+ n = c.parse(n);
+ }this._data.concat(n);this._nDataBytes += n.sigBytes;
+ }, _process: function _process(w) {
+ var q = this._data;var x = q.words;var n = q.sigBytes;var t = this.blockSize;var v = t * 4;var u = n / v;if (w) {
+ u = e.ceil(u);
+ } else {
+ u = e.max((u | 0) - this._minBufferSize, 0);
+ }var s = u * t;var r = e.min(s * 4, n);if (s) {
+ for (var p = 0; p < s; p += t) {
+ this._doProcessBlock(x, p);
+ }var o = x.splice(0, s);q.sigBytes -= r;
+ }return new l.init(o, r);
+ }, clone: function clone() {
+ var n = j.clone.call(this);n._data = this._data.clone();return n;
+ }, _minBufferSize: 0 });var f = b.Hasher = i.extend({ cfg: j.extend(), init: function init(n) {
+ this.cfg = this.cfg.extend(n);this.reset();
+ }, reset: function reset() {
+ i.reset.call(this);this._doReset();
+ }, update: function update(n) {
+ this._append(n);this._process();return this;
+ }, finalize: function finalize(n) {
+ if (n) {
+ this._append(n);
+ }var o = this._doFinalize();return o;
+ }, blockSize: 512 / 32, _createHelper: function _createHelper(n) {
+ return function (p, o) {
+ return new n.init(o).finalize(p);
+ };
+ }, _createHmacHelper: function _createHmacHelper(n) {
+ return function (p, o) {
+ return new k.HMAC.init(n, o).finalize(p);
+ };
+ } });var k = a.algo = {};return a;
+}(Math);
+/*
+CryptoJS v3.1.2 x64-core-min.js
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function (g) {
+ var a = CryptoJS,
+ f = a.lib,
+ e = f.Base,
+ h = f.WordArray,
+ a = a.x64 = {};a.Word = e.extend({ init: function init(b, c) {
+ this.high = b;this.low = c;
+ } });a.WordArray = e.extend({ init: function init(b, c) {
+ b = this.words = b || [];this.sigBytes = c != g ? c : 8 * b.length;
+ }, toX32: function toX32() {
+ for (var b = this.words, c = b.length, a = [], d = 0; d < c; d++) {
+ var e = b[d];a.push(e.high);a.push(e.low);
+ }return h.create(a, this.sigBytes);
+ }, clone: function clone() {
+ for (var b = e.clone.call(this), c = b.words = this.words.slice(0), a = c.length, d = 0; d < a; d++) {
+ c[d] = c[d].clone();
+ }return b;
+ } });
+})();
+
+/*
+CryptoJS v3.1.2 enc-base64.js
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+ var h = CryptoJS,
+ j = h.lib.WordArray;h.enc.Base64 = { stringify: function stringify(b) {
+ var e = b.words,
+ f = b.sigBytes,
+ c = this._map;b.clamp();b = [];for (var a = 0; a < f; a += 3) {
+ for (var d = (e[a >>> 2] >>> 24 - 8 * (a % 4) & 255) << 16 | (e[a + 1 >>> 2] >>> 24 - 8 * ((a + 1) % 4) & 255) << 8 | e[a + 2 >>> 2] >>> 24 - 8 * ((a + 2) % 4) & 255, g = 0; 4 > g && a + 0.75 * g < f; g++) {
+ b.push(c.charAt(d >>> 6 * (3 - g) & 63));
+ }
+ }if (e = c.charAt(64)) for (; b.length % 4;) {
+ b.push(e);
+ }return b.join("");
+ }, parse: function parse(b) {
+ var e = b.length,
+ f = this._map,
+ c = f.charAt(64);c && (c = b.indexOf(c), -1 != c && (e = c));for (var c = [], a = 0, d = 0; d < e; d++) {
+ if (d % 4) {
+ var g = f.indexOf(b.charAt(d - 1)) << 2 * (d % 4),
+ h = f.indexOf(b.charAt(d)) >>> 6 - 2 * (d % 4);c[a >>> 2] |= (g | h) << 24 - 8 * (a % 4);a++;
+ }
+ }return j.create(c, a);
+ }, _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" };
+})();
+
+/*
+CryptoJS v3.1.2 sha256-min.js
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function (k) {
+ for (var g = CryptoJS, h = g.lib, v = h.WordArray, j = h.Hasher, h = g.algo, s = [], t = [], u = function u(q) {
+ return 4294967296 * (q - (q | 0)) | 0;
+ }, l = 2, b = 0; 64 > b;) {
+ var d;a: {
+ d = l;for (var w = k.sqrt(d), r = 2; r <= w; r++) {
+ if (!(d % r)) {
+ d = !1;break a;
+ }
+ }d = !0;
+ }d && (8 > b && (s[b] = u(k.pow(l, 0.5))), t[b] = u(k.pow(l, 1 / 3)), b++);l++;
+ }var n = [],
+ h = h.SHA256 = j.extend({ _doReset: function _doReset() {
+ this._hash = new v.init(s.slice(0));
+ }, _doProcessBlock: function _doProcessBlock(q, h) {
+ for (var a = this._hash.words, c = a[0], d = a[1], b = a[2], k = a[3], f = a[4], g = a[5], j = a[6], l = a[7], e = 0; 64 > e; e++) {
+ if (16 > e) n[e] = q[h + e] | 0;else {
+ var m = n[e - 15],
+ p = n[e - 2];n[e] = ((m << 25 | m >>> 7) ^ (m << 14 | m >>> 18) ^ m >>> 3) + n[e - 7] + ((p << 15 | p >>> 17) ^ (p << 13 | p >>> 19) ^ p >>> 10) + n[e - 16];
+ }m = l + ((f << 26 | f >>> 6) ^ (f << 21 | f >>> 11) ^ (f << 7 | f >>> 25)) + (f & g ^ ~f & j) + t[e] + n[e];p = ((c << 30 | c >>> 2) ^ (c << 19 | c >>> 13) ^ (c << 10 | c >>> 22)) + (c & d ^ c & b ^ d & b);l = j;j = g;g = f;f = k + m | 0;k = b;b = d;d = c;c = m + p | 0;
+ }a[0] = a[0] + c | 0;a[1] = a[1] + d | 0;a[2] = a[2] + b | 0;a[3] = a[3] + k | 0;a[4] = a[4] + f | 0;a[5] = a[5] + g | 0;a[6] = a[6] + j | 0;a[7] = a[7] + l | 0;
+ }, _doFinalize: function _doFinalize() {
+ var d = this._data,
+ b = d.words,
+ a = 8 * this._nDataBytes,
+ c = 8 * d.sigBytes;
+ b[c >>> 5] |= 128 << 24 - c % 32;b[(c + 64 >>> 9 << 4) + 14] = k.floor(a / 4294967296);b[(c + 64 >>> 9 << 4) + 15] = a;d.sigBytes = 4 * b.length;this._process();return this._hash;
+ }, clone: function clone() {
+ var b = j.clone.call(this);b._hash = this._hash.clone();return b;
+ } });g.SHA256 = j._createHelper(h);g.HmacSHA256 = j._createHmacHelper(h);
+})(Math);
+
+/*
+CryptoJS v3.1.2 sha512-min.js
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+ function a() {
+ return d.create.apply(d, arguments);
+ }for (var n = CryptoJS, r = n.lib.Hasher, e = n.x64, d = e.Word, T = e.WordArray, e = n.algo, ea = [a(1116352408, 3609767458), a(1899447441, 602891725), a(3049323471, 3964484399), a(3921009573, 2173295548), a(961987163, 4081628472), a(1508970993, 3053834265), a(2453635748, 2937671579), a(2870763221, 3664609560), a(3624381080, 2734883394), a(310598401, 1164996542), a(607225278, 1323610764), a(1426881987, 3590304994), a(1925078388, 4068182383), a(2162078206, 991336113), a(2614888103, 633803317), a(3248222580, 3479774868), a(3835390401, 2666613458), a(4022224774, 944711139), a(264347078, 2341262773), a(604807628, 2007800933), a(770255983, 1495990901), a(1249150122, 1856431235), a(1555081692, 3175218132), a(1996064986, 2198950837), a(2554220882, 3999719339), a(2821834349, 766784016), a(2952996808, 2566594879), a(3210313671, 3203337956), a(3336571891, 1034457026), a(3584528711, 2466948901), a(113926993, 3758326383), a(338241895, 168717936), a(666307205, 1188179964), a(773529912, 1546045734), a(1294757372, 1522805485), a(1396182291, 2643833823), a(1695183700, 2343527390), a(1986661051, 1014477480), a(2177026350, 1206759142), a(2456956037, 344077627), a(2730485921, 1290863460), a(2820302411, 3158454273), a(3259730800, 3505952657), a(3345764771, 106217008), a(3516065817, 3606008344), a(3600352804, 1432725776), a(4094571909, 1467031594), a(275423344, 851169720), a(430227734, 3100823752), a(506948616, 1363258195), a(659060556, 3750685593), a(883997877, 3785050280), a(958139571, 3318307427), a(1322822218, 3812723403), a(1537002063, 2003034995), a(1747873779, 3602036899), a(1955562222, 1575990012), a(2024104815, 1125592928), a(2227730452, 2716904306), a(2361852424, 442776044), a(2428436474, 593698344), a(2756734187, 3733110249), a(3204031479, 2999351573), a(3329325298, 3815920427), a(3391569614, 3928383900), a(3515267271, 566280711), a(3940187606, 3454069534), a(4118630271, 4000239992), a(116418474, 1914138554), a(174292421, 2731055270), a(289380356, 3203993006), a(460393269, 320620315), a(685471733, 587496836), a(852142971, 1086792851), a(1017036298, 365543100), a(1126000580, 2618297676), a(1288033470, 3409855158), a(1501505948, 4234509866), a(1607167915, 987167468), a(1816402316, 1246189591)], v = [], w = 0; 80 > w; w++) {
+ v[w] = a();
+ }e = e.SHA512 = r.extend({ _doReset: function _doReset() {
+ this._hash = new T.init([new d.init(1779033703, 4089235720), new d.init(3144134277, 2227873595), new d.init(1013904242, 4271175723), new d.init(2773480762, 1595750129), new d.init(1359893119, 2917565137), new d.init(2600822924, 725511199), new d.init(528734635, 4215389547), new d.init(1541459225, 327033209)]);
+ }, _doProcessBlock: function _doProcessBlock(a, d) {
+ for (var f = this._hash.words, F = f[0], e = f[1], n = f[2], r = f[3], G = f[4], H = f[5], I = f[6], f = f[7], w = F.high, J = F.low, X = e.high, K = e.low, Y = n.high, L = n.low, Z = r.high, M = r.low, $ = G.high, N = G.low, aa = H.high, O = H.low, ba = I.high, P = I.low, ca = f.high, Q = f.low, k = w, g = J, z = X, x = K, A = Y, y = L, U = Z, B = M, l = $, h = N, R = aa, C = O, S = ba, D = P, V = ca, E = Q, m = 0; 80 > m; m++) {
+ var s = v[m];if (16 > m) var j = s.high = a[d + 2 * m] | 0,
+ b = s.low = a[d + 2 * m + 1] | 0;else {
+ var j = v[m - 15],
+ b = j.high,
+ p = j.low,
+ j = (b >>> 1 | p << 31) ^ (b >>> 8 | p << 24) ^ b >>> 7,
+ p = (p >>> 1 | b << 31) ^ (p >>> 8 | b << 24) ^ (p >>> 7 | b << 25),
+ u = v[m - 2],
+ b = u.high,
+ c = u.low,
+ u = (b >>> 19 | c << 13) ^ (b << 3 | c >>> 29) ^ b >>> 6,
+ c = (c >>> 19 | b << 13) ^ (c << 3 | b >>> 29) ^ (c >>> 6 | b << 26),
+ b = v[m - 7],
+ W = b.high,
+ t = v[m - 16],
+ q = t.high,
+ t = t.low,
+ b = p + b.low,
+ j = j + W + (b >>> 0 < p >>> 0 ? 1 : 0),
+ b = b + c,
+ j = j + u + (b >>> 0 < c >>> 0 ? 1 : 0),
+ b = b + t,
+ j = j + q + (b >>> 0 < t >>> 0 ? 1 : 0);s.high = j;s.low = b;
+ }var W = l & R ^ ~l & S,
+ t = h & C ^ ~h & D,
+ s = k & z ^ k & A ^ z & A,
+ T = g & x ^ g & y ^ x & y,
+ p = (k >>> 28 | g << 4) ^ (k << 30 | g >>> 2) ^ (k << 25 | g >>> 7),
+ u = (g >>> 28 | k << 4) ^ (g << 30 | k >>> 2) ^ (g << 25 | k >>> 7),
+ c = ea[m],
+ fa = c.high,
+ da = c.low,
+ c = E + ((h >>> 14 | l << 18) ^ (h >>> 18 | l << 14) ^ (h << 23 | l >>> 9)),
+ q = V + ((l >>> 14 | h << 18) ^ (l >>> 18 | h << 14) ^ (l << 23 | h >>> 9)) + (c >>> 0 < E >>> 0 ? 1 : 0),
+ c = c + t,
+ q = q + W + (c >>> 0 < t >>> 0 ? 1 : 0),
+ c = c + da,
+ q = q + fa + (c >>> 0 < da >>> 0 ? 1 : 0),
+ c = c + b,
+ q = q + j + (c >>> 0 < b >>> 0 ? 1 : 0),
+ b = u + T,
+ s = p + s + (b >>> 0 < u >>> 0 ? 1 : 0),
+ V = S,
+ E = D,
+ S = R,
+ D = C,
+ R = l,
+ C = h,
+ h = B + c | 0,
+ l = U + q + (h >>> 0 < B >>> 0 ? 1 : 0) | 0,
+ U = A,
+ B = y,
+ A = z,
+ y = x,
+ z = k,
+ x = g,
+ g = c + b | 0,
+ k = q + s + (g >>> 0 < c >>> 0 ? 1 : 0) | 0;
+ }J = F.low = J + g;F.high = w + k + (J >>> 0 < g >>> 0 ? 1 : 0);K = e.low = K + x;e.high = X + z + (K >>> 0 < x >>> 0 ? 1 : 0);L = n.low = L + y;n.high = Y + A + (L >>> 0 < y >>> 0 ? 1 : 0);M = r.low = M + B;r.high = Z + U + (M >>> 0 < B >>> 0 ? 1 : 0);N = G.low = N + h;G.high = $ + l + (N >>> 0 < h >>> 0 ? 1 : 0);O = H.low = O + C;H.high = aa + R + (O >>> 0 < C >>> 0 ? 1 : 0);P = I.low = P + D;
+ I.high = ba + S + (P >>> 0 < D >>> 0 ? 1 : 0);Q = f.low = Q + E;f.high = ca + V + (Q >>> 0 < E >>> 0 ? 1 : 0);
+ }, _doFinalize: function _doFinalize() {
+ var a = this._data,
+ d = a.words,
+ f = 8 * this._nDataBytes,
+ e = 8 * a.sigBytes;d[e >>> 5] |= 128 << 24 - e % 32;d[(e + 128 >>> 10 << 5) + 30] = Math.floor(f / 4294967296);d[(e + 128 >>> 10 << 5) + 31] = f;a.sigBytes = 4 * d.length;this._process();return this._hash.toX32();
+ }, clone: function clone() {
+ var a = r.clone.call(this);a._hash = this._hash.clone();return a;
+ }, blockSize: 32 });n.SHA512 = r._createHelper(e);n.HmacSHA512 = r._createHmacHelper(e);
+})();
+
+/*
+CryptoJS v3.1.2 sha384-min.js
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+ var c = CryptoJS,
+ a = c.x64,
+ b = a.Word,
+ e = a.WordArray,
+ a = c.algo,
+ d = a.SHA512,
+ a = a.SHA384 = d.extend({ _doReset: function _doReset() {
+ this._hash = new e.init([new b.init(3418070365, 3238371032), new b.init(1654270250, 914150663), new b.init(2438529370, 812702999), new b.init(355462360, 4144912697), new b.init(1731405415, 4290775857), new b.init(2394180231, 1750603025), new b.init(3675008525, 1694076839), new b.init(1203062813, 3204075428)]);
+ }, _doFinalize: function _doFinalize() {
+ var a = d._doFinalize.call(this);a.sigBytes -= 16;return a;
+ } });c.SHA384 = d._createHelper(a);c.HmacSHA384 = d._createHmacHelper(a);
+})();
+
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+var b64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";var b64pad = "=";function hex2b64(d) {
+ var b;var e;var a = "";for (b = 0; b + 3 <= d.length; b += 3) {
+ e = parseInt(d.substring(b, b + 3), 16);a += b64map.charAt(e >> 6) + b64map.charAt(e & 63);
+ }if (b + 1 == d.length) {
+ e = parseInt(d.substring(b, b + 1), 16);a += b64map.charAt(e << 2);
+ } else {
+ if (b + 2 == d.length) {
+ e = parseInt(d.substring(b, b + 2), 16);a += b64map.charAt(e >> 2) + b64map.charAt((e & 3) << 4);
+ }
+ }if (b64pad) {
+ while ((a.length & 3) > 0) {
+ a += b64pad;
+ }
+ }return a;
+}function b64tohex(f) {
+ var d = "";var e;var b = 0;var c;var a;for (e = 0; e < f.length; ++e) {
+ if (f.charAt(e) == b64pad) {
+ break;
+ }a = b64map.indexOf(f.charAt(e));if (a < 0) {
+ continue;
+ }if (b == 0) {
+ d += int2char(a >> 2);c = a & 3;b = 1;
+ } else {
+ if (b == 1) {
+ d += int2char(c << 2 | a >> 4);c = a & 15;b = 2;
+ } else {
+ if (b == 2) {
+ d += int2char(c);d += int2char(a >> 2);c = a & 3;b = 3;
+ } else {
+ d += int2char(c << 2 | a >> 4);d += int2char(a & 15);b = 0;
+ }
+ }
+ }
+ }if (b == 1) {
+ d += int2char(c << 2);
+ }return d;
+}function b64toBA(e) {
+ var d = b64tohex(e);var c;var b = new Array();for (c = 0; 2 * c < d.length; ++c) {
+ b[c] = parseInt(d.substring(2 * c, 2 * c + 2), 16);
+ }return b;
+};
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+var dbits;var canary = 244837814094590;var j_lm = (canary & 16777215) == 15715070;function BigInteger(e, d, f) {
+ if (e != null) {
+ if ("number" == typeof e) {
+ this.fromNumber(e, d, f);
+ } else {
+ if (d == null && "string" != typeof e) {
+ this.fromString(e, 256);
+ } else {
+ this.fromString(e, d);
+ }
+ }
+ }
+}function nbi() {
+ return new BigInteger(null);
+}function am1(f, a, b, e, h, g) {
+ while (--g >= 0) {
+ var d = a * this[f++] + b[e] + h;h = Math.floor(d / 67108864);b[e++] = d & 67108863;
+ }return h;
+}function am2(f, q, r, e, o, a) {
+ var k = q & 32767,
+ p = q >> 15;while (--a >= 0) {
+ var d = this[f] & 32767;var g = this[f++] >> 15;var b = p * d + g * k;d = k * d + ((b & 32767) << 15) + r[e] + (o & 1073741823);o = (d >>> 30) + (b >>> 15) + p * g + (o >>> 30);r[e++] = d & 1073741823;
+ }return o;
+}function am3(f, q, r, e, o, a) {
+ var k = q & 16383,
+ p = q >> 14;while (--a >= 0) {
+ var d = this[f] & 16383;var g = this[f++] >> 14;var b = p * d + g * k;d = k * d + ((b & 16383) << 14) + r[e] + o;o = (d >> 28) + (b >> 14) + p * g;r[e++] = d & 268435455;
+ }return o;
+}if (j_lm && navigator.appName == "Microsoft Internet Explorer") {
+ BigInteger.prototype.am = am2;dbits = 30;
+} else {
+ if (j_lm && navigator.appName != "Netscape") {
+ BigInteger.prototype.am = am1;dbits = 26;
+ } else {
+ BigInteger.prototype.am = am3;dbits = 28;
+ }
+}BigInteger.prototype.DB = dbits;BigInteger.prototype.DM = (1 << dbits) - 1;BigInteger.prototype.DV = 1 << dbits;var BI_FP = 52;BigInteger.prototype.FV = Math.pow(2, BI_FP);BigInteger.prototype.F1 = BI_FP - dbits;BigInteger.prototype.F2 = 2 * dbits - BI_FP;var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";var BI_RC = new Array();var rr, vv;rr = "0".charCodeAt(0);for (vv = 0; vv <= 9; ++vv) {
+ BI_RC[rr++] = vv;
+}rr = "a".charCodeAt(0);for (vv = 10; vv < 36; ++vv) {
+ BI_RC[rr++] = vv;
+}rr = "A".charCodeAt(0);for (vv = 10; vv < 36; ++vv) {
+ BI_RC[rr++] = vv;
+}function int2char(a) {
+ return BI_RM.charAt(a);
+}function intAt(b, a) {
+ var d = BI_RC[b.charCodeAt(a)];return d == null ? -1 : d;
+}function bnpCopyTo(b) {
+ for (var a = this.t - 1; a >= 0; --a) {
+ b[a] = this[a];
+ }b.t = this.t;b.s = this.s;
+}function bnpFromInt(a) {
+ this.t = 1;this.s = a < 0 ? -1 : 0;if (a > 0) {
+ this[0] = a;
+ } else {
+ if (a < -1) {
+ this[0] = a + this.DV;
+ } else {
+ this.t = 0;
+ }
+ }
+}function nbv(a) {
+ var b = nbi();b.fromInt(a);return b;
+}function bnpFromString(h, c) {
+ var e;if (c == 16) {
+ e = 4;
+ } else {
+ if (c == 8) {
+ e = 3;
+ } else {
+ if (c == 256) {
+ e = 8;
+ } else {
+ if (c == 2) {
+ e = 1;
+ } else {
+ if (c == 32) {
+ e = 5;
+ } else {
+ if (c == 4) {
+ e = 2;
+ } else {
+ this.fromRadix(h, c);return;
+ }
+ }
+ }
+ }
+ }
+ }this.t = 0;this.s = 0;var g = h.length,
+ d = false,
+ f = 0;while (--g >= 0) {
+ var a = e == 8 ? h[g] & 255 : intAt(h, g);if (a < 0) {
+ if (h.charAt(g) == "-") {
+ d = true;
+ }continue;
+ }d = false;if (f == 0) {
+ this[this.t++] = a;
+ } else {
+ if (f + e > this.DB) {
+ this[this.t - 1] |= (a & (1 << this.DB - f) - 1) << f;this[this.t++] = a >> this.DB - f;
+ } else {
+ this[this.t - 1] |= a << f;
+ }
+ }f += e;if (f >= this.DB) {
+ f -= this.DB;
+ }
+ }if (e == 8 && (h[0] & 128) != 0) {
+ this.s = -1;if (f > 0) {
+ this[this.t - 1] |= (1 << this.DB - f) - 1 << f;
+ }
+ }this.clamp();if (d) {
+ BigInteger.ZERO.subTo(this, this);
+ }
+}function bnpClamp() {
+ var a = this.s & this.DM;while (this.t > 0 && this[this.t - 1] == a) {
+ --this.t;
+ }
+}function bnToString(c) {
+ if (this.s < 0) {
+ return "-" + this.negate().toString(c);
+ }var e;if (c == 16) {
+ e = 4;
+ } else {
+ if (c == 8) {
+ e = 3;
+ } else {
+ if (c == 2) {
+ e = 1;
+ } else {
+ if (c == 32) {
+ e = 5;
+ } else {
+ if (c == 4) {
+ e = 2;
+ } else {
+ return this.toRadix(c);
+ }
+ }
+ }
+ }
+ }var g = (1 << e) - 1,
+ l,
+ a = false,
+ h = "",
+ f = this.t;var j = this.DB - f * this.DB % e;if (f-- > 0) {
+ if (j < this.DB && (l = this[f] >> j) > 0) {
+ a = true;h = int2char(l);
+ }while (f >= 0) {
+ if (j < e) {
+ l = (this[f] & (1 << j) - 1) << e - j;l |= this[--f] >> (j += this.DB - e);
+ } else {
+ l = this[f] >> (j -= e) & g;if (j <= 0) {
+ j += this.DB;--f;
+ }
+ }if (l > 0) {
+ a = true;
+ }if (a) {
+ h += int2char(l);
+ }
+ }
+ }return a ? h : "0";
+}function bnNegate() {
+ var a = nbi();BigInteger.ZERO.subTo(this, a);return a;
+}function bnAbs() {
+ return this.s < 0 ? this.negate() : this;
+}function bnCompareTo(b) {
+ var d = this.s - b.s;if (d != 0) {
+ return d;
+ }var c = this.t;d = c - b.t;if (d != 0) {
+ return this.s < 0 ? -d : d;
+ }while (--c >= 0) {
+ if ((d = this[c] - b[c]) != 0) {
+ return d;
+ }
+ }return 0;
+}function nbits(a) {
+ var c = 1,
+ b;if ((b = a >>> 16) != 0) {
+ a = b;c += 16;
+ }if ((b = a >> 8) != 0) {
+ a = b;c += 8;
+ }if ((b = a >> 4) != 0) {
+ a = b;c += 4;
+ }if ((b = a >> 2) != 0) {
+ a = b;c += 2;
+ }if ((b = a >> 1) != 0) {
+ a = b;c += 1;
+ }return c;
+}function bnBitLength() {
+ if (this.t <= 0) {
+ return 0;
+ }return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
+}function bnpDLShiftTo(c, b) {
+ var a;for (a = this.t - 1; a >= 0; --a) {
+ b[a + c] = this[a];
+ }for (a = c - 1; a >= 0; --a) {
+ b[a] = 0;
+ }b.t = this.t + c;b.s = this.s;
+}function bnpDRShiftTo(c, b) {
+ for (var a = c; a < this.t; ++a) {
+ b[a - c] = this[a];
+ }b.t = Math.max(this.t - c, 0);b.s = this.s;
+}function bnpLShiftTo(j, e) {
+ var b = j % this.DB;var a = this.DB - b;var g = (1 << a) - 1;var f = Math.floor(j / this.DB),
+ h = this.s << b & this.DM,
+ d;for (d = this.t - 1; d >= 0; --d) {
+ e[d + f + 1] = this[d] >> a | h;h = (this[d] & g) << b;
+ }for (d = f - 1; d >= 0; --d) {
+ e[d] = 0;
+ }e[f] = h;e.t = this.t + f + 1;e.s = this.s;e.clamp();
+}function bnpRShiftTo(g, d) {
+ d.s = this.s;var e = Math.floor(g / this.DB);if (e >= this.t) {
+ d.t = 0;return;
+ }var b = g % this.DB;var a = this.DB - b;var f = (1 << b) - 1;d[0] = this[e] >> b;for (var c = e + 1; c < this.t; ++c) {
+ d[c - e - 1] |= (this[c] & f) << a;d[c - e] = this[c] >> b;
+ }if (b > 0) {
+ d[this.t - e - 1] |= (this.s & f) << a;
+ }d.t = this.t - e;d.clamp();
+}function bnpSubTo(d, f) {
+ var e = 0,
+ g = 0,
+ b = Math.min(d.t, this.t);while (e < b) {
+ g += this[e] - d[e];f[e++] = g & this.DM;g >>= this.DB;
+ }if (d.t < this.t) {
+ g -= d.s;while (e < this.t) {
+ g += this[e];f[e++] = g & this.DM;g >>= this.DB;
+ }g += this.s;
+ } else {
+ g += this.s;while (e < d.t) {
+ g -= d[e];f[e++] = g & this.DM;g >>= this.DB;
+ }g -= d.s;
+ }f.s = g < 0 ? -1 : 0;if (g < -1) {
+ f[e++] = this.DV + g;
+ } else {
+ if (g > 0) {
+ f[e++] = g;
+ }
+ }f.t = e;f.clamp();
+}function bnpMultiplyTo(c, e) {
+ var b = this.abs(),
+ f = c.abs();var d = b.t;e.t = d + f.t;while (--d >= 0) {
+ e[d] = 0;
+ }for (d = 0; d < f.t; ++d) {
+ e[d + b.t] = b.am(0, f[d], e, d, 0, b.t);
+ }e.s = 0;e.clamp();if (this.s != c.s) {
+ BigInteger.ZERO.subTo(e, e);
+ }
+}function bnpSquareTo(d) {
+ var a = this.abs();var b = d.t = 2 * a.t;while (--b >= 0) {
+ d[b] = 0;
+ }for (b = 0; b < a.t - 1; ++b) {
+ var e = a.am(b, a[b], d, 2 * b, 0, 1);if ((d[b + a.t] += a.am(b + 1, 2 * a[b], d, 2 * b + 1, e, a.t - b - 1)) >= a.DV) {
+ d[b + a.t] -= a.DV;d[b + a.t + 1] = 1;
+ }
+ }if (d.t > 0) {
+ d[d.t - 1] += a.am(b, a[b], d, 2 * b, 0, 1);
+ }d.s = 0;d.clamp();
+}function bnpDivRemTo(n, h, g) {
+ var w = n.abs();if (w.t <= 0) {
+ return;
+ }var k = this.abs();if (k.t < w.t) {
+ if (h != null) {
+ h.fromInt(0);
+ }if (g != null) {
+ this.copyTo(g);
+ }return;
+ }if (g == null) {
+ g = nbi();
+ }var d = nbi(),
+ a = this.s,
+ l = n.s;var v = this.DB - nbits(w[w.t - 1]);if (v > 0) {
+ w.lShiftTo(v, d);k.lShiftTo(v, g);
+ } else {
+ w.copyTo(d);k.copyTo(g);
+ }var p = d.t;var b = d[p - 1];if (b == 0) {
+ return;
+ }var o = b * (1 << this.F1) + (p > 1 ? d[p - 2] >> this.F2 : 0);var A = this.FV / o,
+ z = (1 << this.F1) / o,
+ x = 1 << this.F2;var u = g.t,
+ s = u - p,
+ f = h == null ? nbi() : h;d.dlShiftTo(s, f);if (g.compareTo(f) >= 0) {
+ g[g.t++] = 1;g.subTo(f, g);
+ }BigInteger.ONE.dlShiftTo(p, f);f.subTo(d, d);while (d.t < p) {
+ d[d.t++] = 0;
+ }while (--s >= 0) {
+ var c = g[--u] == b ? this.DM : Math.floor(g[u] * A + (g[u - 1] + x) * z);if ((g[u] += d.am(0, c, g, s, 0, p)) < c) {
+ d.dlShiftTo(s, f);g.subTo(f, g);while (g[u] < --c) {
+ g.subTo(f, g);
+ }
+ }
+ }if (h != null) {
+ g.drShiftTo(p, h);if (a != l) {
+ BigInteger.ZERO.subTo(h, h);
+ }
+ }g.t = p;g.clamp();if (v > 0) {
+ g.rShiftTo(v, g);
+ }if (a < 0) {
+ BigInteger.ZERO.subTo(g, g);
+ }
+}function bnMod(b) {
+ var c = nbi();this.abs().divRemTo(b, null, c);if (this.s < 0 && c.compareTo(BigInteger.ZERO) > 0) {
+ b.subTo(c, c);
+ }return c;
+}function Classic(a) {
+ this.m = a;
+}function cConvert(a) {
+ if (a.s < 0 || a.compareTo(this.m) >= 0) {
+ return a.mod(this.m);
+ } else {
+ return a;
+ }
+}function cRevert(a) {
+ return a;
+}function cReduce(a) {
+ a.divRemTo(this.m, null, a);
+}function cMulTo(a, c, b) {
+ a.multiplyTo(c, b);this.reduce(b);
+}function cSqrTo(a, b) {
+ a.squareTo(b);this.reduce(b);
+}Classic.prototype.convert = cConvert;Classic.prototype.revert = cRevert;Classic.prototype.reduce = cReduce;Classic.prototype.mulTo = cMulTo;Classic.prototype.sqrTo = cSqrTo;function bnpInvDigit() {
+ if (this.t < 1) {
+ return 0;
+ }var a = this[0];if ((a & 1) == 0) {
+ return 0;
+ }var b = a & 3;b = b * (2 - (a & 15) * b) & 15;b = b * (2 - (a & 255) * b) & 255;b = b * (2 - ((a & 65535) * b & 65535)) & 65535;b = b * (2 - a * b % this.DV) % this.DV;return b > 0 ? this.DV - b : -b;
+}function Montgomery(a) {
+ this.m = a;this.mp = a.invDigit();this.mpl = this.mp & 32767;this.mph = this.mp >> 15;this.um = (1 << a.DB - 15) - 1;this.mt2 = 2 * a.t;
+}function montConvert(a) {
+ var b = nbi();a.abs().dlShiftTo(this.m.t, b);b.divRemTo(this.m, null, b);if (a.s < 0 && b.compareTo(BigInteger.ZERO) > 0) {
+ this.m.subTo(b, b);
+ }return b;
+}function montRevert(a) {
+ var b = nbi();a.copyTo(b);this.reduce(b);return b;
+}function montReduce(a) {
+ while (a.t <= this.mt2) {
+ a[a.t++] = 0;
+ }for (var c = 0; c < this.m.t; ++c) {
+ var b = a[c] & 32767;var d = b * this.mpl + ((b * this.mph + (a[c] >> 15) * this.mpl & this.um) << 15) & a.DM;b = c + this.m.t;a[b] += this.m.am(0, d, a, c, 0, this.m.t);while (a[b] >= a.DV) {
+ a[b] -= a.DV;a[++b]++;
+ }
+ }a.clamp();a.drShiftTo(this.m.t, a);if (a.compareTo(this.m) >= 0) {
+ a.subTo(this.m, a);
+ }
+}function montSqrTo(a, b) {
+ a.squareTo(b);this.reduce(b);
+}function montMulTo(a, c, b) {
+ a.multiplyTo(c, b);this.reduce(b);
+}Montgomery.prototype.convert = montConvert;Montgomery.prototype.revert = montRevert;Montgomery.prototype.reduce = montReduce;Montgomery.prototype.mulTo = montMulTo;Montgomery.prototype.sqrTo = montSqrTo;function bnpIsEven() {
+ return (this.t > 0 ? this[0] & 1 : this.s) == 0;
+}function bnpExp(h, j) {
+ if (h > 4294967295 || h < 1) {
+ return BigInteger.ONE;
+ }var f = nbi(),
+ a = nbi(),
+ d = j.convert(this),
+ c = nbits(h) - 1;d.copyTo(f);while (--c >= 0) {
+ j.sqrTo(f, a);if ((h & 1 << c) > 0) {
+ j.mulTo(a, d, f);
+ } else {
+ var b = f;f = a;a = b;
+ }
+ }return j.revert(f);
+}function bnModPowInt(b, a) {
+ var c;if (b < 256 || a.isEven()) {
+ c = new Classic(a);
+ } else {
+ c = new Montgomery(a);
+ }return this.exp(b, c);
+}BigInteger.prototype.copyTo = bnpCopyTo;BigInteger.prototype.fromInt = bnpFromInt;BigInteger.prototype.fromString = bnpFromString;BigInteger.prototype.clamp = bnpClamp;BigInteger.prototype.dlShiftTo = bnpDLShiftTo;BigInteger.prototype.drShiftTo = bnpDRShiftTo;BigInteger.prototype.lShiftTo = bnpLShiftTo;BigInteger.prototype.rShiftTo = bnpRShiftTo;BigInteger.prototype.subTo = bnpSubTo;BigInteger.prototype.multiplyTo = bnpMultiplyTo;BigInteger.prototype.squareTo = bnpSquareTo;BigInteger.prototype.divRemTo = bnpDivRemTo;BigInteger.prototype.invDigit = bnpInvDigit;BigInteger.prototype.isEven = bnpIsEven;BigInteger.prototype.exp = bnpExp;BigInteger.prototype.toString = bnToString;BigInteger.prototype.negate = bnNegate;BigInteger.prototype.abs = bnAbs;BigInteger.prototype.compareTo = bnCompareTo;BigInteger.prototype.bitLength = bnBitLength;BigInteger.prototype.mod = bnMod;BigInteger.prototype.modPowInt = bnModPowInt;BigInteger.ZERO = nbv(0);BigInteger.ONE = nbv(1);
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+function bnClone() {
+ var a = nbi();this.copyTo(a);return a;
+}function bnIntValue() {
+ if (this.s < 0) {
+ if (this.t == 1) {
+ return this[0] - this.DV;
+ } else {
+ if (this.t == 0) {
+ return -1;
+ }
+ }
+ } else {
+ if (this.t == 1) {
+ return this[0];
+ } else {
+ if (this.t == 0) {
+ return 0;
+ }
+ }
+ }return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0];
+}function bnByteValue() {
+ return this.t == 0 ? this.s : this[0] << 24 >> 24;
+}function bnShortValue() {
+ return this.t == 0 ? this.s : this[0] << 16 >> 16;
+}function bnpChunkSize(a) {
+ return Math.floor(Math.LN2 * this.DB / Math.log(a));
+}function bnSigNum() {
+ if (this.s < 0) {
+ return -1;
+ } else {
+ if (this.t <= 0 || this.t == 1 && this[0] <= 0) {
+ return 0;
+ } else {
+ return 1;
+ }
+ }
+}function bnpToRadix(c) {
+ if (c == null) {
+ c = 10;
+ }if (this.signum() == 0 || c < 2 || c > 36) {
+ return "0";
+ }var f = this.chunkSize(c);var e = Math.pow(c, f);var i = nbv(e),
+ j = nbi(),
+ h = nbi(),
+ g = "";this.divRemTo(i, j, h);while (j.signum() > 0) {
+ g = (e + h.intValue()).toString(c).substr(1) + g;j.divRemTo(i, j, h);
+ }return h.intValue().toString(c) + g;
+}function bnpFromRadix(m, h) {
+ this.fromInt(0);if (h == null) {
+ h = 10;
+ }var f = this.chunkSize(h);var g = Math.pow(h, f),
+ e = false,
+ a = 0,
+ l = 0;for (var c = 0; c < m.length; ++c) {
+ var k = intAt(m, c);if (k < 0) {
+ if (m.charAt(c) == "-" && this.signum() == 0) {
+ e = true;
+ }continue;
+ }l = h * l + k;if (++a >= f) {
+ this.dMultiply(g);this.dAddOffset(l, 0);a = 0;l = 0;
+ }
+ }if (a > 0) {
+ this.dMultiply(Math.pow(h, a));this.dAddOffset(l, 0);
+ }if (e) {
+ BigInteger.ZERO.subTo(this, this);
+ }
+}function bnpFromNumber(f, e, h) {
+ if ("number" == typeof e) {
+ if (f < 2) {
+ this.fromInt(1);
+ } else {
+ this.fromNumber(f, h);if (!this.testBit(f - 1)) {
+ this.bitwiseTo(BigInteger.ONE.shiftLeft(f - 1), op_or, this);
+ }if (this.isEven()) {
+ this.dAddOffset(1, 0);
+ }while (!this.isProbablePrime(e)) {
+ this.dAddOffset(2, 0);if (this.bitLength() > f) {
+ this.subTo(BigInteger.ONE.shiftLeft(f - 1), this);
+ }
+ }
+ }
+ } else {
+ var d = new Array(),
+ g = f & 7;d.length = (f >> 3) + 1;e.nextBytes(d);if (g > 0) {
+ d[0] &= (1 << g) - 1;
+ } else {
+ d[0] = 0;
+ }this.fromString(d, 256);
+ }
+}function bnToByteArray() {
+ var b = this.t,
+ c = new Array();c[0] = this.s;var e = this.DB - b * this.DB % 8,
+ f,
+ a = 0;if (b-- > 0) {
+ if (e < this.DB && (f = this[b] >> e) != (this.s & this.DM) >> e) {
+ c[a++] = f | this.s << this.DB - e;
+ }while (b >= 0) {
+ if (e < 8) {
+ f = (this[b] & (1 << e) - 1) << 8 - e;f |= this[--b] >> (e += this.DB - 8);
+ } else {
+ f = this[b] >> (e -= 8) & 255;if (e <= 0) {
+ e += this.DB;--b;
+ }
+ }if ((f & 128) != 0) {
+ f |= -256;
+ }if (a == 0 && (this.s & 128) != (f & 128)) {
+ ++a;
+ }if (a > 0 || f != this.s) {
+ c[a++] = f;
+ }
+ }
+ }return c;
+}function bnEquals(b) {
+ return this.compareTo(b) == 0;
+}function bnMin(b) {
+ return this.compareTo(b) < 0 ? this : b;
+}function bnMax(b) {
+ return this.compareTo(b) > 0 ? this : b;
+}function bnpBitwiseTo(c, h, e) {
+ var d,
+ g,
+ b = Math.min(c.t, this.t);for (d = 0; d < b; ++d) {
+ e[d] = h(this[d], c[d]);
+ }if (c.t < this.t) {
+ g = c.s & this.DM;for (d = b; d < this.t; ++d) {
+ e[d] = h(this[d], g);
+ }e.t = this.t;
+ } else {
+ g = this.s & this.DM;for (d = b; d < c.t; ++d) {
+ e[d] = h(g, c[d]);
+ }e.t = c.t;
+ }e.s = h(this.s, c.s);e.clamp();
+}function op_and(a, b) {
+ return a & b;
+}function bnAnd(b) {
+ var c = nbi();this.bitwiseTo(b, op_and, c);return c;
+}function op_or(a, b) {
+ return a | b;
+}function bnOr(b) {
+ var c = nbi();this.bitwiseTo(b, op_or, c);return c;
+}function op_xor(a, b) {
+ return a ^ b;
+}function bnXor(b) {
+ var c = nbi();this.bitwiseTo(b, op_xor, c);return c;
+}function op_andnot(a, b) {
+ return a & ~b;
+}function bnAndNot(b) {
+ var c = nbi();this.bitwiseTo(b, op_andnot, c);return c;
+}function bnNot() {
+ var b = nbi();for (var a = 0; a < this.t; ++a) {
+ b[a] = this.DM & ~this[a];
+ }b.t = this.t;b.s = ~this.s;return b;
+}function bnShiftLeft(b) {
+ var a = nbi();if (b < 0) {
+ this.rShiftTo(-b, a);
+ } else {
+ this.lShiftTo(b, a);
+ }return a;
+}function bnShiftRight(b) {
+ var a = nbi();if (b < 0) {
+ this.lShiftTo(-b, a);
+ } else {
+ this.rShiftTo(b, a);
+ }return a;
+}function lbit(a) {
+ if (a == 0) {
+ return -1;
+ }var b = 0;if ((a & 65535) == 0) {
+ a >>= 16;b += 16;
+ }if ((a & 255) == 0) {
+ a >>= 8;b += 8;
+ }if ((a & 15) == 0) {
+ a >>= 4;b += 4;
+ }if ((a & 3) == 0) {
+ a >>= 2;b += 2;
+ }if ((a & 1) == 0) {
+ ++b;
+ }return b;
+}function bnGetLowestSetBit() {
+ for (var a = 0; a < this.t; ++a) {
+ if (this[a] != 0) {
+ return a * this.DB + lbit(this[a]);
+ }
+ }if (this.s < 0) {
+ return this.t * this.DB;
+ }return -1;
+}function cbit(a) {
+ var b = 0;while (a != 0) {
+ a &= a - 1;++b;
+ }return b;
+}function bnBitCount() {
+ var c = 0,
+ a = this.s & this.DM;for (var b = 0; b < this.t; ++b) {
+ c += cbit(this[b] ^ a);
+ }return c;
+}function bnTestBit(b) {
+ var a = Math.floor(b / this.DB);if (a >= this.t) {
+ return this.s != 0;
+ }return (this[a] & 1 << b % this.DB) != 0;
+}function bnpChangeBit(c, b) {
+ var a = BigInteger.ONE.shiftLeft(c);this.bitwiseTo(a, b, a);return a;
+}function bnSetBit(a) {
+ return this.changeBit(a, op_or);
+}function bnClearBit(a) {
+ return this.changeBit(a, op_andnot);
+}function bnFlipBit(a) {
+ return this.changeBit(a, op_xor);
+}function bnpAddTo(d, f) {
+ var e = 0,
+ g = 0,
+ b = Math.min(d.t, this.t);while (e < b) {
+ g += this[e] + d[e];f[e++] = g & this.DM;g >>= this.DB;
+ }if (d.t < this.t) {
+ g += d.s;while (e < this.t) {
+ g += this[e];f[e++] = g & this.DM;g >>= this.DB;
+ }g += this.s;
+ } else {
+ g += this.s;while (e < d.t) {
+ g += d[e];f[e++] = g & this.DM;g >>= this.DB;
+ }g += d.s;
+ }f.s = g < 0 ? -1 : 0;if (g > 0) {
+ f[e++] = g;
+ } else {
+ if (g < -1) {
+ f[e++] = this.DV + g;
+ }
+ }f.t = e;f.clamp();
+}function bnAdd(b) {
+ var c = nbi();this.addTo(b, c);return c;
+}function bnSubtract(b) {
+ var c = nbi();this.subTo(b, c);return c;
+}function bnMultiply(b) {
+ var c = nbi();this.multiplyTo(b, c);return c;
+}function bnSquare() {
+ var a = nbi();this.squareTo(a);return a;
+}function bnDivide(b) {
+ var c = nbi();this.divRemTo(b, c, null);return c;
+}function bnRemainder(b) {
+ var c = nbi();this.divRemTo(b, null, c);return c;
+}function bnDivideAndRemainder(b) {
+ var d = nbi(),
+ c = nbi();this.divRemTo(b, d, c);return new Array(d, c);
+}function bnpDMultiply(a) {
+ this[this.t] = this.am(0, a - 1, this, 0, 0, this.t);++this.t;this.clamp();
+}function bnpDAddOffset(b, a) {
+ if (b == 0) {
+ return;
+ }while (this.t <= a) {
+ this[this.t++] = 0;
+ }this[a] += b;while (this[a] >= this.DV) {
+ this[a] -= this.DV;if (++a >= this.t) {
+ this[this.t++] = 0;
+ }++this[a];
+ }
+}function NullExp() {}function nNop(a) {
+ return a;
+}function nMulTo(a, c, b) {
+ a.multiplyTo(c, b);
+}function nSqrTo(a, b) {
+ a.squareTo(b);
+}NullExp.prototype.convert = nNop;NullExp.prototype.revert = nNop;NullExp.prototype.mulTo = nMulTo;NullExp.prototype.sqrTo = nSqrTo;function bnPow(a) {
+ return this.exp(a, new NullExp());
+}function bnpMultiplyLowerTo(b, f, e) {
+ var d = Math.min(this.t + b.t, f);e.s = 0;e.t = d;while (d > 0) {
+ e[--d] = 0;
+ }var c;for (c = e.t - this.t; d < c; ++d) {
+ e[d + this.t] = this.am(0, b[d], e, d, 0, this.t);
+ }for (c = Math.min(b.t, f); d < c; ++d) {
+ this.am(0, b[d], e, d, 0, f - d);
+ }e.clamp();
+}function bnpMultiplyUpperTo(b, e, d) {
+ --e;var c = d.t = this.t + b.t - e;d.s = 0;while (--c >= 0) {
+ d[c] = 0;
+ }for (c = Math.max(e - this.t, 0); c < b.t; ++c) {
+ d[this.t + c - e] = this.am(e - c, b[c], d, 0, 0, this.t + c - e);
+ }d.clamp();d.drShiftTo(1, d);
+}function Barrett(a) {
+ this.r2 = nbi();this.q3 = nbi();BigInteger.ONE.dlShiftTo(2 * a.t, this.r2);this.mu = this.r2.divide(a);this.m = a;
+}function barrettConvert(a) {
+ if (a.s < 0 || a.t > 2 * this.m.t) {
+ return a.mod(this.m);
+ } else {
+ if (a.compareTo(this.m) < 0) {
+ return a;
+ } else {
+ var b = nbi();a.copyTo(b);this.reduce(b);return b;
+ }
+ }
+}function barrettRevert(a) {
+ return a;
+}function barrettReduce(a) {
+ a.drShiftTo(this.m.t - 1, this.r2);if (a.t > this.m.t + 1) {
+ a.t = this.m.t + 1;a.clamp();
+ }this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);while (a.compareTo(this.r2) < 0) {
+ a.dAddOffset(1, this.m.t + 1);
+ }a.subTo(this.r2, a);while (a.compareTo(this.m) >= 0) {
+ a.subTo(this.m, a);
+ }
+}function barrettSqrTo(a, b) {
+ a.squareTo(b);this.reduce(b);
+}function barrettMulTo(a, c, b) {
+ a.multiplyTo(c, b);this.reduce(b);
+}Barrett.prototype.convert = barrettConvert;Barrett.prototype.revert = barrettRevert;Barrett.prototype.reduce = barrettReduce;Barrett.prototype.mulTo = barrettMulTo;Barrett.prototype.sqrTo = barrettSqrTo;function bnModPow(q, f) {
+ var o = q.bitLength(),
+ h,
+ b = nbv(1),
+ v;if (o <= 0) {
+ return b;
+ } else {
+ if (o < 18) {
+ h = 1;
+ } else {
+ if (o < 48) {
+ h = 3;
+ } else {
+ if (o < 144) {
+ h = 4;
+ } else {
+ if (o < 768) {
+ h = 5;
+ } else {
+ h = 6;
+ }
+ }
+ }
+ }
+ }if (o < 8) {
+ v = new Classic(f);
+ } else {
+ if (f.isEven()) {
+ v = new Barrett(f);
+ } else {
+ v = new Montgomery(f);
+ }
+ }var p = new Array(),
+ d = 3,
+ s = h - 1,
+ a = (1 << h) - 1;p[1] = v.convert(this);if (h > 1) {
+ var A = nbi();v.sqrTo(p[1], A);while (d <= a) {
+ p[d] = nbi();v.mulTo(A, p[d - 2], p[d]);d += 2;
+ }
+ }var l = q.t - 1,
+ x,
+ u = true,
+ c = nbi(),
+ y;o = nbits(q[l]) - 1;while (l >= 0) {
+ if (o >= s) {
+ x = q[l] >> o - s & a;
+ } else {
+ x = (q[l] & (1 << o + 1) - 1) << s - o;if (l > 0) {
+ x |= q[l - 1] >> this.DB + o - s;
+ }
+ }d = h;while ((x & 1) == 0) {
+ x >>= 1;--d;
+ }if ((o -= d) < 0) {
+ o += this.DB;--l;
+ }if (u) {
+ p[x].copyTo(b);u = false;
+ } else {
+ while (d > 1) {
+ v.sqrTo(b, c);v.sqrTo(c, b);d -= 2;
+ }if (d > 0) {
+ v.sqrTo(b, c);
+ } else {
+ y = b;b = c;c = y;
+ }v.mulTo(c, p[x], b);
+ }while (l >= 0 && (q[l] & 1 << o) == 0) {
+ v.sqrTo(b, c);y = b;b = c;c = y;if (--o < 0) {
+ o = this.DB - 1;--l;
+ }
+ }
+ }return v.revert(b);
+}function bnGCD(c) {
+ var b = this.s < 0 ? this.negate() : this.clone();var h = c.s < 0 ? c.negate() : c.clone();if (b.compareTo(h) < 0) {
+ var e = b;b = h;h = e;
+ }var d = b.getLowestSetBit(),
+ f = h.getLowestSetBit();if (f < 0) {
+ return b;
+ }if (d < f) {
+ f = d;
+ }if (f > 0) {
+ b.rShiftTo(f, b);h.rShiftTo(f, h);
+ }while (b.signum() > 0) {
+ if ((d = b.getLowestSetBit()) > 0) {
+ b.rShiftTo(d, b);
+ }if ((d = h.getLowestSetBit()) > 0) {
+ h.rShiftTo(d, h);
+ }if (b.compareTo(h) >= 0) {
+ b.subTo(h, b);b.rShiftTo(1, b);
+ } else {
+ h.subTo(b, h);h.rShiftTo(1, h);
+ }
+ }if (f > 0) {
+ h.lShiftTo(f, h);
+ }return h;
+}function bnpModInt(e) {
+ if (e <= 0) {
+ return 0;
+ }var c = this.DV % e,
+ b = this.s < 0 ? e - 1 : 0;if (this.t > 0) {
+ if (c == 0) {
+ b = this[0] % e;
+ } else {
+ for (var a = this.t - 1; a >= 0; --a) {
+ b = (c * b + this[a]) % e;
+ }
+ }
+ }return b;
+}function bnModInverse(f) {
+ var j = f.isEven();if (this.isEven() && j || f.signum() == 0) {
+ return BigInteger.ZERO;
+ }var i = f.clone(),
+ h = this.clone();var g = nbv(1),
+ e = nbv(0),
+ l = nbv(0),
+ k = nbv(1);while (i.signum() != 0) {
+ while (i.isEven()) {
+ i.rShiftTo(1, i);if (j) {
+ if (!g.isEven() || !e.isEven()) {
+ g.addTo(this, g);e.subTo(f, e);
+ }g.rShiftTo(1, g);
+ } else {
+ if (!e.isEven()) {
+ e.subTo(f, e);
+ }
+ }e.rShiftTo(1, e);
+ }while (h.isEven()) {
+ h.rShiftTo(1, h);if (j) {
+ if (!l.isEven() || !k.isEven()) {
+ l.addTo(this, l);k.subTo(f, k);
+ }l.rShiftTo(1, l);
+ } else {
+ if (!k.isEven()) {
+ k.subTo(f, k);
+ }
+ }k.rShiftTo(1, k);
+ }if (i.compareTo(h) >= 0) {
+ i.subTo(h, i);if (j) {
+ g.subTo(l, g);
+ }e.subTo(k, e);
+ } else {
+ h.subTo(i, h);if (j) {
+ l.subTo(g, l);
+ }k.subTo(e, k);
+ }
+ }if (h.compareTo(BigInteger.ONE) != 0) {
+ return BigInteger.ZERO;
+ }if (k.compareTo(f) >= 0) {
+ return k.subtract(f);
+ }if (k.signum() < 0) {
+ k.addTo(f, k);
+ } else {
+ return k;
+ }if (k.signum() < 0) {
+ return k.add(f);
+ } else {
+ return k;
+ }
+}var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];function bnIsProbablePrime(e) {
+ var d,
+ b = this.abs();if (b.t == 1 && b[0] <= lowprimes[lowprimes.length - 1]) {
+ for (d = 0; d < lowprimes.length; ++d) {
+ if (b[0] == lowprimes[d]) {
+ return true;
+ }
+ }return false;
+ }if (b.isEven()) {
+ return false;
+ }d = 1;while (d < lowprimes.length) {
+ var a = lowprimes[d],
+ c = d + 1;while (c < lowprimes.length && a < lplim) {
+ a *= lowprimes[c++];
+ }a = b.modInt(a);while (d < c) {
+ if (a % lowprimes[d++] == 0) {
+ return false;
+ }
+ }
+ }return b.millerRabin(e);
+}function bnpMillerRabin(f) {
+ var g = this.subtract(BigInteger.ONE);var c = g.getLowestSetBit();if (c <= 0) {
+ return false;
+ }var h = g.shiftRight(c);f = f + 1 >> 1;if (f > lowprimes.length) {
+ f = lowprimes.length;
+ }var b = nbi();for (var e = 0; e < f; ++e) {
+ b.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);var l = b.modPow(h, this);if (l.compareTo(BigInteger.ONE) != 0 && l.compareTo(g) != 0) {
+ var d = 1;while (d++ < c && l.compareTo(g) != 0) {
+ l = l.modPowInt(2, this);if (l.compareTo(BigInteger.ONE) == 0) {
+ return false;
+ }
+ }if (l.compareTo(g) != 0) {
+ return false;
+ }
+ }
+ }return true;
+}BigInteger.prototype.chunkSize = bnpChunkSize;BigInteger.prototype.toRadix = bnpToRadix;BigInteger.prototype.fromRadix = bnpFromRadix;BigInteger.prototype.fromNumber = bnpFromNumber;BigInteger.prototype.bitwiseTo = bnpBitwiseTo;BigInteger.prototype.changeBit = bnpChangeBit;BigInteger.prototype.addTo = bnpAddTo;BigInteger.prototype.dMultiply = bnpDMultiply;BigInteger.prototype.dAddOffset = bnpDAddOffset;BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;BigInteger.prototype.modInt = bnpModInt;BigInteger.prototype.millerRabin = bnpMillerRabin;BigInteger.prototype.clone = bnClone;BigInteger.prototype.intValue = bnIntValue;BigInteger.prototype.byteValue = bnByteValue;BigInteger.prototype.shortValue = bnShortValue;BigInteger.prototype.signum = bnSigNum;BigInteger.prototype.toByteArray = bnToByteArray;BigInteger.prototype.equals = bnEquals;BigInteger.prototype.min = bnMin;BigInteger.prototype.max = bnMax;BigInteger.prototype.and = bnAnd;BigInteger.prototype.or = bnOr;BigInteger.prototype.xor = bnXor;BigInteger.prototype.andNot = bnAndNot;BigInteger.prototype.not = bnNot;BigInteger.prototype.shiftLeft = bnShiftLeft;BigInteger.prototype.shiftRight = bnShiftRight;BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;BigInteger.prototype.bitCount = bnBitCount;BigInteger.prototype.testBit = bnTestBit;BigInteger.prototype.setBit = bnSetBit;BigInteger.prototype.clearBit = bnClearBit;BigInteger.prototype.flipBit = bnFlipBit;BigInteger.prototype.add = bnAdd;BigInteger.prototype.subtract = bnSubtract;BigInteger.prototype.multiply = bnMultiply;BigInteger.prototype.divide = bnDivide;BigInteger.prototype.remainder = bnRemainder;BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;BigInteger.prototype.modPow = bnModPow;BigInteger.prototype.modInverse = bnModInverse;BigInteger.prototype.pow = bnPow;BigInteger.prototype.gcd = bnGCD;BigInteger.prototype.isProbablePrime = bnIsProbablePrime;BigInteger.prototype.square = bnSquare;
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+function Arcfour() {
+ this.i = 0;this.j = 0;this.S = new Array();
+}function ARC4init(d) {
+ var c, a, b;for (c = 0; c < 256; ++c) {
+ this.S[c] = c;
+ }a = 0;for (c = 0; c < 256; ++c) {
+ a = a + this.S[c] + d[c % d.length] & 255;b = this.S[c];this.S[c] = this.S[a];this.S[a] = b;
+ }this.i = 0;this.j = 0;
+}function ARC4next() {
+ var a;this.i = this.i + 1 & 255;this.j = this.j + this.S[this.i] & 255;a = this.S[this.i];this.S[this.i] = this.S[this.j];this.S[this.j] = a;return this.S[a + this.S[this.i] & 255];
+}Arcfour.prototype.init = ARC4init;Arcfour.prototype.next = ARC4next;function prng_newstate() {
+ return new Arcfour();
+}var rng_psize = 256;
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+var rng_state;var rng_pool;var rng_pptr;function rng_seed_int(a) {
+ rng_pool[rng_pptr++] ^= a & 255;rng_pool[rng_pptr++] ^= a >> 8 & 255;rng_pool[rng_pptr++] ^= a >> 16 & 255;rng_pool[rng_pptr++] ^= a >> 24 & 255;if (rng_pptr >= rng_psize) {
+ rng_pptr -= rng_psize;
+ }
+}function rng_seed_time() {
+ rng_seed_int(new Date().getTime());
+}if (rng_pool == null) {
+ rng_pool = new Array();rng_pptr = 0;var t;if (window !== undefined && (window.crypto !== undefined || window.msCrypto !== undefined)) {
+ var crypto = window.crypto || window.msCrypto;if (crypto.getRandomValues) {
+ var ua = new Uint8Array(32);crypto.getRandomValues(ua);for (t = 0; t < 32; ++t) {
+ rng_pool[rng_pptr++] = ua[t];
+ }
+ } else {
+ if (navigator.appName == "Netscape" && navigator.appVersion < "5") {
+ var z = window.crypto.random(32);for (t = 0; t < z.length; ++t) {
+ rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
+ }
+ }
+ }
+ }while (rng_pptr < rng_psize) {
+ t = Math.floor(65536 * Math.random());rng_pool[rng_pptr++] = t >>> 8;rng_pool[rng_pptr++] = t & 255;
+ }rng_pptr = 0;rng_seed_time();
+}function rng_get_byte() {
+ if (rng_state == null) {
+ rng_seed_time();rng_state = prng_newstate();rng_state.init(rng_pool);for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
+ rng_pool[rng_pptr] = 0;
+ }rng_pptr = 0;
+ }return rng_state.next();
+}function rng_get_bytes(b) {
+ var a;for (a = 0; a < b.length; ++a) {
+ b[a] = rng_get_byte();
+ }
+}function SecureRandom() {}SecureRandom.prototype.nextBytes = rng_get_bytes;
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+function parseBigInt(b, a) {
+ return new BigInteger(b, a);
+}function linebrk(c, d) {
+ var a = "";var b = 0;while (b + d < c.length) {
+ a += c.substring(b, b + d) + "\n";b += d;
+ }return a + c.substring(b, c.length);
+}function byte2Hex(a) {
+ if (a < 16) {
+ return "0" + a.toString(16);
+ } else {
+ return a.toString(16);
+ }
+}function pkcs1pad2(e, h) {
+ if (h < e.length + 11) {
+ throw "Message too long for RSA";return null;
+ }var g = new Array();var d = e.length - 1;while (d >= 0 && h > 0) {
+ var f = e.charCodeAt(d--);if (f < 128) {
+ g[--h] = f;
+ } else {
+ if (f > 127 && f < 2048) {
+ g[--h] = f & 63 | 128;g[--h] = f >> 6 | 192;
+ } else {
+ g[--h] = f & 63 | 128;g[--h] = f >> 6 & 63 | 128;g[--h] = f >> 12 | 224;
+ }
+ }
+ }g[--h] = 0;var b = new SecureRandom();var a = new Array();while (h > 2) {
+ a[0] = 0;while (a[0] == 0) {
+ b.nextBytes(a);
+ }g[--h] = a[0];
+ }g[--h] = 2;g[--h] = 0;return new BigInteger(g);
+}function oaep_mgf1_arr(c, a, e) {
+ var b = "",
+ d = 0;while (b.length < a) {
+ b += e(String.fromCharCode.apply(String, c.concat([(d & 4278190080) >> 24, (d & 16711680) >> 16, (d & 65280) >> 8, d & 255])));d += 1;
+ }return b;
+}function oaep_pad(q, a, f, l) {
+ var c = KJUR.crypto.MessageDigest;var o = KJUR.crypto.Util;var b = null;if (!f) {
+ f = "sha1";
+ }if (typeof f === "string") {
+ b = c.getCanonicalAlgName(f);l = c.getHashLength(b);f = function f(i) {
+ return hextorstr(o.hashHex(rstrtohex(i), b));
+ };
+ }if (q.length + 2 * l + 2 > a) {
+ throw "Message too long for RSA";
+ }var k = "",
+ e;for (e = 0; e < a - q.length - 2 * l - 2; e += 1) {
+ k += "\x00";
+ }var h = f("") + k + "\x01" + q;var g = new Array(l);new SecureRandom().nextBytes(g);var j = oaep_mgf1_arr(g, h.length, f);var p = [];for (e = 0; e < h.length; e += 1) {
+ p[e] = h.charCodeAt(e) ^ j.charCodeAt(e);
+ }var m = oaep_mgf1_arr(p, g.length, f);var d = [0];for (e = 0; e < g.length; e += 1) {
+ d[e + 1] = g[e] ^ m.charCodeAt(e);
+ }return new BigInteger(d.concat(p));
+}function RSAKey() {
+ this.n = null;this.e = 0;this.d = null;this.p = null;this.q = null;this.dmp1 = null;this.dmq1 = null;this.coeff = null;
+}function RSASetPublic(b, a) {
+ this.isPublic = true;this.isPrivate = false;if (typeof b !== "string") {
+ this.n = b;this.e = a;
+ } else {
+ if (b != null && a != null && b.length > 0 && a.length > 0) {
+ this.n = parseBigInt(b, 16);this.e = parseInt(a, 16);
+ } else {
+ throw "Invalid RSA public key";
+ }
+ }
+}function RSADoPublic(a) {
+ return a.modPowInt(this.e, this.n);
+}function RSAEncrypt(d) {
+ var a = pkcs1pad2(d, this.n.bitLength() + 7 >> 3);if (a == null) {
+ return null;
+ }var e = this.doPublic(a);if (e == null) {
+ return null;
+ }var b = e.toString(16);if ((b.length & 1) == 0) {
+ return b;
+ } else {
+ return "0" + b;
+ }
+}function RSAEncryptOAEP(f, e, b) {
+ var a = oaep_pad(f, this.n.bitLength() + 7 >> 3, e, b);if (a == null) {
+ return null;
+ }var g = this.doPublic(a);if (g == null) {
+ return null;
+ }var d = g.toString(16);if ((d.length & 1) == 0) {
+ return d;
+ } else {
+ return "0" + d;
+ }
+}RSAKey.prototype.doPublic = RSADoPublic;RSAKey.prototype.setPublic = RSASetPublic;RSAKey.prototype.encrypt = RSAEncrypt;RSAKey.prototype.encryptOAEP = RSAEncryptOAEP;RSAKey.prototype.type = "RSA";
+/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+ */
+function ECFieldElementFp(b, a) {
+ this.x = a;this.q = b;
+}function feFpEquals(a) {
+ if (a == this) {
+ return true;
+ }return this.q.equals(a.q) && this.x.equals(a.x);
+}function feFpToBigInteger() {
+ return this.x;
+}function feFpNegate() {
+ return new ECFieldElementFp(this.q, this.x.negate().mod(this.q));
+}function feFpAdd(a) {
+ return new ECFieldElementFp(this.q, this.x.add(a.toBigInteger()).mod(this.q));
+}function feFpSubtract(a) {
+ return new ECFieldElementFp(this.q, this.x.subtract(a.toBigInteger()).mod(this.q));
+}function feFpMultiply(a) {
+ return new ECFieldElementFp(this.q, this.x.multiply(a.toBigInteger()).mod(this.q));
+}function feFpSquare() {
+ return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
+}function feFpDivide(a) {
+ return new ECFieldElementFp(this.q, this.x.multiply(a.toBigInteger().modInverse(this.q)).mod(this.q));
+}ECFieldElementFp.prototype.equals = feFpEquals;ECFieldElementFp.prototype.toBigInteger = feFpToBigInteger;ECFieldElementFp.prototype.negate = feFpNegate;ECFieldElementFp.prototype.add = feFpAdd;ECFieldElementFp.prototype.subtract = feFpSubtract;ECFieldElementFp.prototype.multiply = feFpMultiply;ECFieldElementFp.prototype.square = feFpSquare;ECFieldElementFp.prototype.divide = feFpDivide;function ECPointFp(c, a, d, b) {
+ this.curve = c;this.x = a;this.y = d;if (b == null) {
+ this.z = BigInteger.ONE;
+ } else {
+ this.z = b;
+ }this.zinv = null;
+}function pointFpGetX() {
+ if (this.zinv == null) {
+ this.zinv = this.z.modInverse(this.curve.q);
+ }return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q));
+}function pointFpGetY() {
+ if (this.zinv == null) {
+ this.zinv = this.z.modInverse(this.curve.q);
+ }return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q));
+}function pointFpEquals(a) {
+ if (a == this) {
+ return true;
+ }if (this.isInfinity()) {
+ return a.isInfinity();
+ }if (a.isInfinity()) {
+ return this.isInfinity();
+ }var c, b;c = a.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(a.z)).mod(this.curve.q);if (!c.equals(BigInteger.ZERO)) {
+ return false;
+ }b = a.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(a.z)).mod(this.curve.q);return b.equals(BigInteger.ZERO);
+}function pointFpIsInfinity() {
+ if (this.x == null && this.y == null) {
+ return true;
+ }return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO);
+}function pointFpNegate() {
+ return new ECPointFp(this.curve, this.x, this.y.negate(), this.z);
+}function pointFpAdd(l) {
+ if (this.isInfinity()) {
+ return l;
+ }if (l.isInfinity()) {
+ return this;
+ }var p = l.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(l.z)).mod(this.curve.q);var o = l.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(l.z)).mod(this.curve.q);if (BigInteger.ZERO.equals(o)) {
+ if (BigInteger.ZERO.equals(p)) {
+ return this.twice();
+ }return this.curve.getInfinity();
+ }var j = new BigInteger("3");var e = this.x.toBigInteger();var n = this.y.toBigInteger();var c = l.x.toBigInteger();var k = l.y.toBigInteger();var m = o.square();var i = m.multiply(o);var d = e.multiply(m);var g = p.square().multiply(this.z);var a = g.subtract(d.shiftLeft(1)).multiply(l.z).subtract(i).multiply(o).mod(this.curve.q);var h = d.multiply(j).multiply(p).subtract(n.multiply(i)).subtract(g.multiply(p)).multiply(l.z).add(p.multiply(i)).mod(this.curve.q);var f = i.multiply(this.z).multiply(l.z).mod(this.curve.q);return new ECPointFp(this.curve, this.curve.fromBigInteger(a), this.curve.fromBigInteger(h), f);
+}function pointFpTwice() {
+ if (this.isInfinity()) {
+ return this;
+ }if (this.y.toBigInteger().signum() == 0) {
+ return this.curve.getInfinity();
+ }var g = new BigInteger("3");var c = this.x.toBigInteger();var h = this.y.toBigInteger();var e = h.multiply(this.z);var j = e.multiply(h).mod(this.curve.q);var i = this.curve.a.toBigInteger();var k = c.square().multiply(g);if (!BigInteger.ZERO.equals(i)) {
+ k = k.add(this.z.square().multiply(i));
+ }k = k.mod(this.curve.q);var b = k.square().subtract(c.shiftLeft(3).multiply(j)).shiftLeft(1).multiply(e).mod(this.curve.q);var f = k.multiply(g).multiply(c).subtract(j.shiftLeft(1)).shiftLeft(2).multiply(j).subtract(k.square().multiply(k)).mod(this.curve.q);var d = e.square().multiply(e).shiftLeft(3).mod(this.curve.q);return new ECPointFp(this.curve, this.curve.fromBigInteger(b), this.curve.fromBigInteger(f), d);
+}function pointFpMultiply(d) {
+ if (this.isInfinity()) {
+ return this;
+ }if (d.signum() == 0) {
+ return this.curve.getInfinity();
+ }var m = d;var l = m.multiply(new BigInteger("3"));var b = this.negate();var j = this;var q = this.curve.q.subtract(d);var o = q.multiply(new BigInteger("3"));var c = new ECPointFp(this.curve, this.x, this.y);var a = c.negate();var g;for (g = l.bitLength() - 2; g > 0; --g) {
+ j = j.twice();var n = l.testBit(g);var f = m.testBit(g);if (n != f) {
+ j = j.add(n ? this : b);
+ }
+ }for (g = o.bitLength() - 2; g > 0; --g) {
+ c = c.twice();var p = o.testBit(g);var r = q.testBit(g);if (p != r) {
+ c = c.add(p ? c : a);
+ }
+ }return j;
+}function pointFpMultiplyTwo(c, a, b) {
+ var d;if (c.bitLength() > b.bitLength()) {
+ d = c.bitLength() - 1;
+ } else {
+ d = b.bitLength() - 1;
+ }var f = this.curve.getInfinity();var e = this.add(a);while (d >= 0) {
+ f = f.twice();if (c.testBit(d)) {
+ if (b.testBit(d)) {
+ f = f.add(e);
+ } else {
+ f = f.add(this);
+ }
+ } else {
+ if (b.testBit(d)) {
+ f = f.add(a);
+ }
+ }--d;
+ }return f;
+}ECPointFp.prototype.getX = pointFpGetX;ECPointFp.prototype.getY = pointFpGetY;ECPointFp.prototype.equals = pointFpEquals;ECPointFp.prototype.isInfinity = pointFpIsInfinity;ECPointFp.prototype.negate = pointFpNegate;ECPointFp.prototype.add = pointFpAdd;ECPointFp.prototype.twice = pointFpTwice;ECPointFp.prototype.multiply = pointFpMultiply;ECPointFp.prototype.multiplyTwo = pointFpMultiplyTwo;function ECCurveFp(e, d, c) {
+ this.q = e;this.a = this.fromBigInteger(d);this.b = this.fromBigInteger(c);this.infinity = new ECPointFp(this, null, null);
+}function curveFpGetQ() {
+ return this.q;
+}function curveFpGetA() {
+ return this.a;
+}function curveFpGetB() {
+ return this.b;
+}function curveFpEquals(a) {
+ if (a == this) {
+ return true;
+ }return this.q.equals(a.q) && this.a.equals(a.a) && this.b.equals(a.b);
+}function curveFpGetInfinity() {
+ return this.infinity;
+}function curveFpFromBigInteger(a) {
+ return new ECFieldElementFp(this.q, a);
+}function curveFpDecodePointHex(d) {
+ switch (parseInt(d.substr(0, 2), 16)) {case 0:
+ return this.infinity;case 2:case 3:
+ return null;case 4:case 6:case 7:
+ var a = (d.length - 2) / 2;var c = d.substr(2, a);var b = d.substr(a + 2, a);return new ECPointFp(this, this.fromBigInteger(new BigInteger(c, 16)), this.fromBigInteger(new BigInteger(b, 16)));default:
+ return null;}
+}ECCurveFp.prototype.getQ = curveFpGetQ;ECCurveFp.prototype.getA = curveFpGetA;ECCurveFp.prototype.getB = curveFpGetB;ECCurveFp.prototype.equals = curveFpEquals;ECCurveFp.prototype.getInfinity = curveFpGetInfinity;ECCurveFp.prototype.fromBigInteger = curveFpFromBigInteger;ECCurveFp.prototype.decodePointHex = curveFpDecodePointHex;
+/*! (c) Stefan Thomas | https://github.com/bitcoinjs/bitcoinjs-lib
+ */
+ECFieldElementFp.prototype.getByteLength = function () {
+ return Math.floor((this.toBigInteger().bitLength() + 7) / 8);
+};ECPointFp.prototype.getEncoded = function (c) {
+ var d = function d(h, f) {
+ var g = h.toByteArrayUnsigned();if (f < g.length) {
+ g = g.slice(g.length - f);
+ } else {
+ while (f > g.length) {
+ g.unshift(0);
+ }
+ }return g;
+ };var a = this.getX().toBigInteger();var e = this.getY().toBigInteger();var b = d(a, 32);if (c) {
+ if (e.isEven()) {
+ b.unshift(2);
+ } else {
+ b.unshift(3);
+ }
+ } else {
+ b.unshift(4);b = b.concat(d(e, 32));
+ }return b;
+};ECPointFp.decodeFrom = function (g, c) {
+ var f = c[0];var e = c.length - 1;var d = c.slice(1, 1 + e / 2);var b = c.slice(1 + e / 2, 1 + e);d.unshift(0);b.unshift(0);var a = new BigInteger(d);var h = new BigInteger(b);return new ECPointFp(g, g.fromBigInteger(a), g.fromBigInteger(h));
+};ECPointFp.decodeFromHex = function (g, c) {
+ var f = c.substr(0, 2);var e = c.length - 2;var d = c.substr(2, e / 2);var b = c.substr(2 + e / 2, e / 2);var a = new BigInteger(d, 16);var h = new BigInteger(b, 16);return new ECPointFp(g, g.fromBigInteger(a), g.fromBigInteger(h));
+};ECPointFp.prototype.add2D = function (c) {
+ if (this.isInfinity()) {
+ return c;
+ }if (c.isInfinity()) {
+ return this;
+ }if (this.x.equals(c.x)) {
+ if (this.y.equals(c.y)) {
+ return this.twice();
+ }return this.curve.getInfinity();
+ }var g = c.x.subtract(this.x);var e = c.y.subtract(this.y);var a = e.divide(g);var d = a.square().subtract(this.x).subtract(c.x);var f = a.multiply(this.x.subtract(d)).subtract(this.y);return new ECPointFp(this.curve, d, f);
+};ECPointFp.prototype.twice2D = function () {
+ if (this.isInfinity()) {
+ return this;
+ }if (this.y.toBigInteger().signum() == 0) {
+ return this.curve.getInfinity();
+ }var b = this.curve.fromBigInteger(BigInteger.valueOf(2));var e = this.curve.fromBigInteger(BigInteger.valueOf(3));var a = this.x.square().multiply(e).add(this.curve.a).divide(this.y.multiply(b));var c = a.square().subtract(this.x.multiply(b));var d = a.multiply(this.x.subtract(c)).subtract(this.y);return new ECPointFp(this.curve, c, d);
+};ECPointFp.prototype.multiply2D = function (b) {
+ if (this.isInfinity()) {
+ return this;
+ }if (b.signum() == 0) {
+ return this.curve.getInfinity();
+ }var g = b;var f = g.multiply(new BigInteger("3"));var l = this.negate();var d = this;var c;for (c = f.bitLength() - 2; c > 0; --c) {
+ d = d.twice();var a = f.testBit(c);var j = g.testBit(c);if (a != j) {
+ d = d.add2D(a ? this : l);
+ }
+ }return d;
+};ECPointFp.prototype.isOnCurve = function () {
+ var d = this.getX().toBigInteger();var i = this.getY().toBigInteger();var f = this.curve.getA().toBigInteger();var c = this.curve.getB().toBigInteger();var h = this.curve.getQ();var e = i.multiply(i).mod(h);var g = d.multiply(d).multiply(d).add(f.multiply(d)).add(c).mod(h);return e.equals(g);
+};ECPointFp.prototype.toString = function () {
+ return "(" + this.getX().toBigInteger().toString() + "," + this.getY().toBigInteger().toString() + ")";
+};ECPointFp.prototype.validate = function () {
+ var c = this.curve.getQ();if (this.isInfinity()) {
+ throw new Error("Point is at infinity.");
+ }var a = this.getX().toBigInteger();var b = this.getY().toBigInteger();if (a.compareTo(BigInteger.ONE) < 0 || a.compareTo(c.subtract(BigInteger.ONE)) > 0) {
+ throw new Error("x coordinate out of bounds");
+ }if (b.compareTo(BigInteger.ONE) < 0 || b.compareTo(c.subtract(BigInteger.ONE)) > 0) {
+ throw new Error("y coordinate out of bounds");
+ }if (!this.isOnCurve()) {
+ throw new Error("Point is not on the curve.");
+ }if (this.multiply(c).isInfinity()) {
+ throw new Error("Point is not a scalar multiple of G.");
+ }return true;
+};
+/*! Mike Samuel (c) 2009 | code.google.com/p/json-sans-eval
+ */
+var jsonParse = function () {
+ var e = "(?:-?\\b(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\\b)";var j = '(?:[^\\0-\\x08\\x0a-\\x1f"\\\\]|\\\\(?:["/\\\\bfnrt]|u[0-9A-Fa-f]{4}))';var i = '(?:"' + j + '*")';var d = new RegExp("(?:false|true|null|[\\{\\}\\[\\]]|" + e + "|" + i + ")", "g");var k = new RegExp("\\\\(?:([^u])|u(.{4}))", "g");var g = { '"': '"', "/": "/", "\\": "\\", b: "\b", f: "\f", n: "\n", r: "\r", t: "\t" };function h(l, m, n) {
+ return m ? g[m] : String.fromCharCode(parseInt(n, 16));
+ }var c = new String("");var a = "\\";var f = { "{": Object, "[": Array };var b = Object.hasOwnProperty;return function (u, q) {
+ var p = u.match(d);var x;var v = p[0];var l = false;if ("{" === v) {
+ x = {};
+ } else {
+ if ("[" === v) {
+ x = [];
+ } else {
+ x = [];l = true;
+ }
+ }var t;var r = [x];for (var o = 1 - l, m = p.length; o < m; ++o) {
+ v = p[o];var w;switch (v.charCodeAt(0)) {default:
+ w = r[0];w[t || w.length] = +v;t = void 0;break;case 34:
+ v = v.substring(1, v.length - 1);if (v.indexOf(a) !== -1) {
+ v = v.replace(k, h);
+ }w = r[0];if (!t) {
+ if (w instanceof Array) {
+ t = w.length;
+ } else {
+ t = v || c;break;
+ }
+ }w[t] = v;t = void 0;break;case 91:
+ w = r[0];r.unshift(w[t || w.length] = []);t = void 0;break;case 93:
+ r.shift();break;case 102:
+ w = r[0];w[t || w.length] = false;t = void 0;break;case 110:
+ w = r[0];w[t || w.length] = null;t = void 0;break;case 116:
+ w = r[0];w[t || w.length] = true;t = void 0;break;case 123:
+ w = r[0];r.unshift(w[t || w.length] = {});t = void 0;break;case 125:
+ r.shift();break;}
+ }if (l) {
+ if (r.length !== 1) {
+ throw new Error();
+ }x = x[0];
+ } else {
+ if (r.length) {
+ throw new Error();
+ }
+ }if (q) {
+ var s = function s(C, B) {
+ var D = C[B];if (D && (typeof D === "undefined" ? "undefined" : _typeof(D)) === "object") {
+ var n = null;for (var z in D) {
+ if (b.call(D, z) && D !== C) {
+ var y = s(D, z);if (y !== void 0) {
+ D[z] = y;
+ } else {
+ if (!n) {
+ n = [];
+ }n.push(z);
+ }
+ }
+ }if (n) {
+ for (var A = n.length; --A >= 0;) {
+ delete D[n[A]];
+ }
+ }
+ }return q.call(C, B, D);
+ };x = s({ "": x }, "");
+ }return x;
+ };
+}();
+if (typeof KJUR == "undefined" || !KJUR) {
+ exports.KJUR = KJUR = {};
+}if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}KJUR.asn1.ASN1Util = new function () {
+ this.integerToByteHex = function (a) {
+ var b = a.toString(16);if (b.length % 2 == 1) {
+ b = "0" + b;
+ }return b;
+ };this.bigIntToMinTwosComplementsHex = function (j) {
+ var f = j.toString(16);if (f.substr(0, 1) != "-") {
+ if (f.length % 2 == 1) {
+ f = "0" + f;
+ } else {
+ if (!f.match(/^[0-7]/)) {
+ f = "00" + f;
+ }
+ }
+ } else {
+ var a = f.substr(1);var e = a.length;if (e % 2 == 1) {
+ e += 1;
+ } else {
+ if (!f.match(/^[0-7]/)) {
+ e += 2;
+ }
+ }var g = "";for (var d = 0; d < e; d++) {
+ g += "f";
+ }var c = new BigInteger(g, 16);var b = c.xor(j).add(BigInteger.ONE);f = b.toString(16).replace(/^-/, "");
+ }return f;
+ };this.getPEMStringFromHex = function (a, b) {
+ return hextopem(a, b);
+ };this.newObject = function (k) {
+ var F = KJUR,
+ o = F.asn1,
+ v = o.ASN1Object,
+ B = o.DERBoolean,
+ e = o.DERInteger,
+ t = o.DERBitString,
+ h = o.DEROctetString,
+ x = o.DERNull,
+ y = o.DERObjectIdentifier,
+ m = o.DEREnumerated,
+ g = o.DERUTF8String,
+ f = o.DERNumericString,
+ A = o.DERPrintableString,
+ w = o.DERTeletexString,
+ q = o.DERIA5String,
+ E = o.DERUTCTime,
+ j = o.DERGeneralizedTime,
+ b = o.DERVisibleString,
+ l = o.DERBMPString,
+ n = o.DERSequence,
+ c = o.DERSet,
+ s = o.DERTaggedObject,
+ p = o.ASN1Util.newObject;if (k instanceof o.ASN1Object) {
+ return k;
+ }var u = Object.keys(k);if (u.length != 1) {
+ throw new Error("key of param shall be only one.");
+ }var H = u[0];if (":asn1:bool:int:bitstr:octstr:null:oid:enum:utf8str:numstr:prnstr:telstr:ia5str:utctime:gentime:visstr:bmpstr:seq:set:tag:".indexOf(":" + H + ":") == -1) {
+ throw new Error("undefined key: " + H);
+ }if (H == "bool") {
+ return new B(k[H]);
+ }if (H == "int") {
+ return new e(k[H]);
+ }if (H == "bitstr") {
+ return new t(k[H]);
+ }if (H == "octstr") {
+ return new h(k[H]);
+ }if (H == "null") {
+ return new x(k[H]);
+ }if (H == "oid") {
+ return new y(k[H]);
+ }if (H == "enum") {
+ return new m(k[H]);
+ }if (H == "utf8str") {
+ return new g(k[H]);
+ }if (H == "numstr") {
+ return new f(k[H]);
+ }if (H == "prnstr") {
+ return new A(k[H]);
+ }if (H == "telstr") {
+ return new w(k[H]);
+ }if (H == "ia5str") {
+ return new q(k[H]);
+ }if (H == "utctime") {
+ return new E(k[H]);
+ }if (H == "gentime") {
+ return new j(k[H]);
+ }if (H == "visstr") {
+ return new b(k[H]);
+ }if (H == "bmpstr") {
+ return new l(k[H]);
+ }if (H == "asn1") {
+ return new v(k[H]);
+ }if (H == "seq") {
+ var d = k[H];var G = [];for (var z = 0; z < d.length; z++) {
+ var D = p(d[z]);G.push(D);
+ }return new n({ array: G });
+ }if (H == "set") {
+ var d = k[H];var G = [];for (var z = 0; z < d.length; z++) {
+ var D = p(d[z]);G.push(D);
+ }return new c({ array: G });
+ }if (H == "tag") {
+ var C = k[H];if (Object.prototype.toString.call(C) === "[object Array]" && C.length == 3) {
+ var r = p(C[2]);return new s({ tag: C[0], explicit: C[1], obj: r });
+ } else {
+ return new s(C);
+ }
+ }
+ };this.jsonToASN1HEX = function (b) {
+ var a = this.newObject(b);return a.getEncodedHex();
+ };
+}();KJUR.asn1.ASN1Util.oidHexToInt = function (a) {
+ var j = "";var k = parseInt(a.substr(0, 2), 16);var d = Math.floor(k / 40);var c = k % 40;var j = d + "." + c;var e = "";for (var f = 2; f < a.length; f += 2) {
+ var g = parseInt(a.substr(f, 2), 16);var h = ("00000000" + g.toString(2)).slice(-8);e = e + h.substr(1, 7);if (h.substr(0, 1) == "0") {
+ var b = new BigInteger(e, 2);j = j + "." + b.toString(10);e = "";
+ }
+ }return j;
+};KJUR.asn1.ASN1Util.oidIntToHex = function (f) {
+ var e = function e(a) {
+ var k = a.toString(16);if (k.length == 1) {
+ k = "0" + k;
+ }return k;
+ };var d = function d(o) {
+ var n = "";var k = new BigInteger(o, 10);var a = k.toString(2);var l = 7 - a.length % 7;if (l == 7) {
+ l = 0;
+ }var q = "";for (var m = 0; m < l; m++) {
+ q += "0";
+ }a = q + a;for (var m = 0; m < a.length - 1; m += 7) {
+ var p = a.substr(m, 7);if (m != a.length - 7) {
+ p = "1" + p;
+ }n += e(parseInt(p, 2));
+ }return n;
+ };if (!f.match(/^[0-9.]+$/)) {
+ throw "malformed oid string: " + f;
+ }var g = "";var b = f.split(".");var j = parseInt(b[0]) * 40 + parseInt(b[1]);g += e(j);b.splice(0, 2);for (var c = 0; c < b.length; c++) {
+ g += d(b[c]);
+ }return g;
+};KJUR.asn1.ASN1Object = function (e) {
+ var c = true;var b = null;var d = "00";var f = "00";var a = "";this.params = null;this.getLengthHexFromValue = function () {
+ if (typeof this.hV == "undefined" || this.hV == null) {
+ throw new Error("this.hV is null or undefined");
+ }if (this.hV.length % 2 == 1) {
+ throw new Error("value hex must be even length: n=" + a.length + ",v=" + this.hV);
+ }var j = this.hV.length / 2;var i = j.toString(16);if (i.length % 2 == 1) {
+ i = "0" + i;
+ }if (j < 128) {
+ return i;
+ } else {
+ var h = i.length / 2;if (h > 15) {
+ throw "ASN.1 length too long to represent by 8x: n = " + j.toString(16);
+ }var g = 128 + h;return g.toString(16) + i;
+ }
+ };this.getEncodedHex = function () {
+ if (this.hTLV == null || this.isModified) {
+ this.hV = this.getFreshValueHex();this.hL = this.getLengthHexFromValue();this.hTLV = this.hT + this.hL + this.hV;this.isModified = false;
+ }return this.hTLV;
+ };this.getValueHex = function () {
+ this.getEncodedHex();return this.hV;
+ };this.getFreshValueHex = function () {
+ return "";
+ };this.setByParam = function (g) {
+ this.params = g;
+ };if (e != undefined) {
+ if (e.tlv != undefined) {
+ this.hTLV = e.tlv;this.isModified = false;
+ }
+ }
+};KJUR.asn1.DERAbstractString = function (c) {
+ KJUR.asn1.DERAbstractString.superclass.constructor.call(this);var b = null;var a = null;this.getString = function () {
+ return this.s;
+ };this.setString = function (d) {
+ this.hTLV = null;this.isModified = true;this.s = d;this.hV = utf8tohex(this.s).toLowerCase();
+ };this.setStringHex = function (d) {
+ this.hTLV = null;this.isModified = true;this.s = null;this.hV = d;
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };if (typeof c != "undefined") {
+ if (typeof c == "string") {
+ this.setString(c);
+ } else {
+ if (typeof c.str != "undefined") {
+ this.setString(c.str);
+ } else {
+ if (typeof c.hex != "undefined") {
+ this.setStringHex(c.hex);
+ }
+ }
+ }
+ }
+};extendClass(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);KJUR.asn1.DERAbstractTime = function (c) {
+ KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);var b = null;var a = null;this.localDateToUTC = function (g) {
+ var e = g.getTime() + g.getTimezoneOffset() * 60000;var f = new Date(e);return f;
+ };this.formatDate = function (m, o, e) {
+ var g = this.zeroPadding;var n = this.localDateToUTC(m);var p = String(n.getFullYear());if (o == "utc") {
+ p = p.substr(2, 2);
+ }var l = g(String(n.getMonth() + 1), 2);var q = g(String(n.getDate()), 2);var h = g(String(n.getHours()), 2);var i = g(String(n.getMinutes()), 2);var j = g(String(n.getSeconds()), 2);var r = p + l + q + h + i + j;if (e === true) {
+ var f = n.getMilliseconds();if (f != 0) {
+ var k = g(String(f), 3);k = k.replace(/[0]+$/, "");r = r + "." + k;
+ }
+ }return r + "Z";
+ };this.zeroPadding = function (e, d) {
+ if (e.length >= d) {
+ return e;
+ }return new Array(d - e.length + 1).join("0") + e;
+ };this.getString = function () {
+ return this.s;
+ };this.setString = function (d) {
+ this.hTLV = null;this.isModified = true;this.s = d;this.hV = stohex(d);
+ };this.setByDateValue = function (h, j, e, d, f, g) {
+ var i = new Date(Date.UTC(h, j - 1, e, d, f, g, 0));this.setByDate(i);
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };
+};extendClass(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);KJUR.asn1.DERAbstractStructured = function (b) {
+ KJUR.asn1.DERAbstractString.superclass.constructor.call(this);var a = null;this.setByASN1ObjectArray = function (c) {
+ this.hTLV = null;this.isModified = true;this.asn1Array = c;
+ };this.appendASN1Object = function (c) {
+ this.hTLV = null;this.isModified = true;this.asn1Array.push(c);
+ };this.asn1Array = new Array();if (typeof b != "undefined") {
+ if (typeof b.array != "undefined") {
+ this.asn1Array = b.array;
+ }
+ }
+};extendClass(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);KJUR.asn1.DERBoolean = function (a) {
+ KJUR.asn1.DERBoolean.superclass.constructor.call(this);this.hT = "01";if (a == false) {
+ this.hTLV = "010100";
+ } else {
+ this.hTLV = "0101ff";
+ }
+};extendClass(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);KJUR.asn1.DERInteger = function (a) {
+ KJUR.asn1.DERInteger.superclass.constructor.call(this);this.hT = "02";this.setByBigInteger = function (b) {
+ this.hTLV = null;this.isModified = true;this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(b);
+ };this.setByInteger = function (c) {
+ var b = new BigInteger(String(c), 10);this.setByBigInteger(b);
+ };this.setValueHex = function (b) {
+ this.hV = b;
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };if (typeof a != "undefined") {
+ if (typeof a.bigint != "undefined") {
+ this.setByBigInteger(a.bigint);
+ } else {
+ if (typeof a["int"] != "undefined") {
+ this.setByInteger(a["int"]);
+ } else {
+ if (typeof a == "number") {
+ this.setByInteger(a);
+ } else {
+ if (typeof a.hex != "undefined") {
+ this.setValueHex(a.hex);
+ }
+ }
+ }
+ }
+ }
+};extendClass(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);KJUR.asn1.DERBitString = function (b) {
+ if (b !== undefined && typeof b.obj !== "undefined") {
+ var a = KJUR.asn1.ASN1Util.newObject(b.obj);b.hex = "00" + a.getEncodedHex();
+ }KJUR.asn1.DERBitString.superclass.constructor.call(this);this.hT = "03";this.setHexValueIncludingUnusedBits = function (c) {
+ this.hTLV = null;this.isModified = true;this.hV = c;
+ };this.setUnusedBitsAndHexValue = function (c, e) {
+ if (c < 0 || 7 < c) {
+ throw "unused bits shall be from 0 to 7: u = " + c;
+ }var d = "0" + c;this.hTLV = null;this.isModified = true;this.hV = d + e;
+ };this.setByBinaryString = function (e) {
+ e = e.replace(/0+$/, "");var f = 8 - e.length % 8;if (f == 8) {
+ f = 0;
+ }for (var g = 0; g <= f; g++) {
+ e += "0";
+ }var j = "";for (var g = 0; g < e.length - 1; g += 8) {
+ var d = e.substr(g, 8);var c = parseInt(d, 2).toString(16);if (c.length == 1) {
+ c = "0" + c;
+ }j += c;
+ }this.hTLV = null;this.isModified = true;this.hV = "0" + f + j;
+ };this.setByBooleanArray = function (e) {
+ var d = "";for (var c = 0; c < e.length; c++) {
+ if (e[c] == true) {
+ d += "1";
+ } else {
+ d += "0";
+ }
+ }this.setByBinaryString(d);
+ };this.newFalseArray = function (e) {
+ var c = new Array(e);for (var d = 0; d < e; d++) {
+ c[d] = false;
+ }return c;
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };if (typeof b != "undefined") {
+ if (typeof b == "string" && b.toLowerCase().match(/^[0-9a-f]+$/)) {
+ this.setHexValueIncludingUnusedBits(b);
+ } else {
+ if (typeof b.hex != "undefined") {
+ this.setHexValueIncludingUnusedBits(b.hex);
+ } else {
+ if (typeof b.bin != "undefined") {
+ this.setByBinaryString(b.bin);
+ } else {
+ if (typeof b.array != "undefined") {
+ this.setByBooleanArray(b.array);
+ }
+ }
+ }
+ }
+ }
+};extendClass(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);KJUR.asn1.DEROctetString = function (b) {
+ if (b !== undefined && typeof b.obj !== "undefined") {
+ var a = KJUR.asn1.ASN1Util.newObject(b.obj);b.hex = a.getEncodedHex();
+ }KJUR.asn1.DEROctetString.superclass.constructor.call(this, b);this.hT = "04";
+};extendClass(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERNull = function () {
+ KJUR.asn1.DERNull.superclass.constructor.call(this);this.hT = "05";this.hTLV = "0500";
+};extendClass(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);KJUR.asn1.DERObjectIdentifier = function (a) {
+ KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);this.hT = "06";this.setValueHex = function (b) {
+ this.hTLV = null;this.isModified = true;this.s = null;this.hV = b;
+ };this.setValueOidString = function (b) {
+ var c = oidtohex(b);if (c == null) {
+ throw new Error("malformed oid string: " + b);
+ }this.hTLV = null;this.isModified = true;this.s = null;this.hV = c;
+ };this.setValueName = function (c) {
+ var b = KJUR.asn1.x509.OID.name2oid(c);if (b !== "") {
+ this.setValueOidString(b);
+ } else {
+ throw new Error("DERObjectIdentifier oidName undefined: " + c);
+ }
+ };this.setValueNameOrOid = function (b) {
+ if (b.match(/^[0-2].[0-9.]+$/)) {
+ this.setValueOidString(b);
+ } else {
+ this.setValueName(b);
+ }
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };this.setByParam = function (b) {
+ if (typeof b === "string") {
+ this.setValueNameOrOid(b);
+ } else {
+ if (b.oid !== undefined) {
+ this.setValueNameOrOid(b.oid);
+ } else {
+ if (b.name !== undefined) {
+ this.setValueNameOrOid(b.name);
+ } else {
+ if (b.hex !== undefined) {
+ this.setValueHex(b.hex);
+ }
+ }
+ }
+ }
+ };if (a !== undefined) {
+ this.setByParam(a);
+ }
+};extendClass(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);KJUR.asn1.DEREnumerated = function (a) {
+ KJUR.asn1.DEREnumerated.superclass.constructor.call(this);this.hT = "0a";this.setByBigInteger = function (b) {
+ this.hTLV = null;this.isModified = true;this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(b);
+ };this.setByInteger = function (c) {
+ var b = new BigInteger(String(c), 10);this.setByBigInteger(b);
+ };this.setValueHex = function (b) {
+ this.hV = b;
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };if (typeof a != "undefined") {
+ if (typeof a["int"] != "undefined") {
+ this.setByInteger(a["int"]);
+ } else {
+ if (typeof a == "number") {
+ this.setByInteger(a);
+ } else {
+ if (typeof a.hex != "undefined") {
+ this.setValueHex(a.hex);
+ }
+ }
+ }
+ }
+};extendClass(KJUR.asn1.DEREnumerated, KJUR.asn1.ASN1Object);KJUR.asn1.DERUTF8String = function (a) {
+ KJUR.asn1.DERUTF8String.superclass.constructor.call(this, a);this.hT = "0c";
+};extendClass(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);KJUR.asn1.DERNumericString = function (a) {
+ KJUR.asn1.DERNumericString.superclass.constructor.call(this, a);this.hT = "12";
+};extendClass(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERPrintableString = function (a) {
+ KJUR.asn1.DERPrintableString.superclass.constructor.call(this, a);this.hT = "13";
+};extendClass(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERTeletexString = function (a) {
+ KJUR.asn1.DERTeletexString.superclass.constructor.call(this, a);this.hT = "14";
+};extendClass(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERIA5String = function (a) {
+ KJUR.asn1.DERIA5String.superclass.constructor.call(this, a);this.hT = "16";
+};extendClass(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);KJUR.asn1.DERVisibleString = function (a) {
+ KJUR.asn1.DERIA5String.superclass.constructor.call(this, a);this.hT = "1a";
+};extendClass(KJUR.asn1.DERVisibleString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERBMPString = function (a) {
+ KJUR.asn1.DERBMPString.superclass.constructor.call(this, a);this.hT = "1e";
+};extendClass(KJUR.asn1.DERBMPString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERUTCTime = function (a) {
+ KJUR.asn1.DERUTCTime.superclass.constructor.call(this, a);this.hT = "17";this.setByDate = function (b) {
+ this.hTLV = null;this.isModified = true;this.date = b;this.s = this.formatDate(this.date, "utc");this.hV = stohex(this.s);
+ };this.getFreshValueHex = function () {
+ if (typeof this.date == "undefined" && typeof this.s == "undefined") {
+ this.date = new Date();this.s = this.formatDate(this.date, "utc");this.hV = stohex(this.s);
+ }return this.hV;
+ };if (a !== undefined) {
+ if (a.str !== undefined) {
+ this.setString(a.str);
+ } else {
+ if (typeof a == "string" && a.match(/^[0-9]{12}Z$/)) {
+ this.setString(a);
+ } else {
+ if (a.hex !== undefined) {
+ this.setStringHex(a.hex);
+ } else {
+ if (a.date !== undefined) {
+ this.setByDate(a.date);
+ }
+ }
+ }
+ }
+ }
+};extendClass(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);KJUR.asn1.DERGeneralizedTime = function (a) {
+ KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, a);this.hT = "18";this.withMillis = false;this.setByDate = function (b) {
+ this.hTLV = null;this.isModified = true;this.date = b;this.s = this.formatDate(this.date, "gen", this.withMillis);this.hV = stohex(this.s);
+ };this.getFreshValueHex = function () {
+ if (this.date === undefined && this.s === undefined) {
+ this.date = new Date();this.s = this.formatDate(this.date, "gen", this.withMillis);this.hV = stohex(this.s);
+ }return this.hV;
+ };if (a !== undefined) {
+ if (a.str !== undefined) {
+ this.setString(a.str);
+ } else {
+ if (typeof a == "string" && a.match(/^[0-9]{14}Z$/)) {
+ this.setString(a);
+ } else {
+ if (a.hex !== undefined) {
+ this.setStringHex(a.hex);
+ } else {
+ if (a.date !== undefined) {
+ this.setByDate(a.date);
+ }
+ }
+ }
+ }if (a.millis === true) {
+ this.withMillis = true;
+ }
+ }
+};extendClass(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);KJUR.asn1.DERSequence = function (a) {
+ KJUR.asn1.DERSequence.superclass.constructor.call(this, a);this.hT = "30";this.getFreshValueHex = function () {
+ var c = "";for (var b = 0; b < this.asn1Array.length; b++) {
+ var d = this.asn1Array[b];c += d.getEncodedHex();
+ }this.hV = c;return this.hV;
+ };
+};extendClass(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);KJUR.asn1.DERSet = function (a) {
+ KJUR.asn1.DERSet.superclass.constructor.call(this, a);this.hT = "31";this.sortFlag = true;this.getFreshValueHex = function () {
+ var b = new Array();for (var c = 0; c < this.asn1Array.length; c++) {
+ var d = this.asn1Array[c];b.push(d.getEncodedHex());
+ }if (this.sortFlag == true) {
+ b.sort();
+ }this.hV = b.join("");return this.hV;
+ };if (typeof a != "undefined") {
+ if (typeof a.sortflag != "undefined" && a.sortflag == false) {
+ this.sortFlag = false;
+ }
+ }
+};extendClass(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);KJUR.asn1.DERTaggedObject = function (b) {
+ KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);var a = KJUR.asn1;this.hT = "a0";this.hV = "";this.isExplicit = true;this.asn1Object = null;this.setASN1Object = function (c, d, e) {
+ this.hT = d;this.isExplicit = c;this.asn1Object = e;if (this.isExplicit) {
+ this.hV = this.asn1Object.getEncodedHex();this.hTLV = null;this.isModified = true;
+ } else {
+ this.hV = null;this.hTLV = e.getEncodedHex();this.hTLV = this.hTLV.replace(/^../, d);this.isModified = false;
+ }
+ };this.getFreshValueHex = function () {
+ return this.hV;
+ };this.setByParam = function (c) {
+ if (c.tag != undefined) {
+ this.hT = c.tag;
+ }if (c.explicit != undefined) {
+ this.isExplicit = c.explicit;
+ }if (c.tage != undefined) {
+ this.hT = c.tage;this.isExplicit = true;
+ }if (c.tagi != undefined) {
+ this.hT = c.tagi;this.isExplicit = false;
+ }if (c.obj != undefined) {
+ if (c.obj instanceof a.ASN1Object) {
+ this.asn1Object = c.obj;this.setASN1Object(this.isExplicit, this.hT, this.asn1Object);
+ } else {
+ if (_typeof(c.obj) == "object") {
+ this.asn1Object = a.ASN1Util.newObject(c.obj);this.setASN1Object(this.isExplicit, this.hT, this.asn1Object);
+ }
+ }
+ }
+ };if (b != undefined) {
+ this.setByParam(b);
+ }
+};extendClass(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);
+var ASN1HEX = new function () {}();ASN1HEX.getLblen = function (c, a) {
+ if (c.substr(a + 2, 1) != "8") {
+ return 1;
+ }var b = parseInt(c.substr(a + 3, 1));if (b == 0) {
+ return -1;
+ }if (0 < b && b < 10) {
+ return b + 1;
+ }return -2;
+};ASN1HEX.getL = function (c, b) {
+ var a = ASN1HEX.getLblen(c, b);if (a < 1) {
+ return "";
+ }return c.substr(b + 2, a * 2);
+};ASN1HEX.getVblen = function (d, a) {
+ var c, b;c = ASN1HEX.getL(d, a);if (c == "") {
+ return -1;
+ }if (c.substr(0, 1) === "8") {
+ b = new BigInteger(c.substr(2), 16);
+ } else {
+ b = new BigInteger(c, 16);
+ }return b.intValue();
+};ASN1HEX.getVidx = function (c, b) {
+ var a = ASN1HEX.getLblen(c, b);if (a < 0) {
+ return a;
+ }return b + (a + 1) * 2;
+};ASN1HEX.getV = function (d, a) {
+ var c = ASN1HEX.getVidx(d, a);var b = ASN1HEX.getVblen(d, a);return d.substr(c, b * 2);
+};ASN1HEX.getTLV = function (b, a) {
+ return b.substr(a, 2) + ASN1HEX.getL(b, a) + ASN1HEX.getV(b, a);
+};ASN1HEX.getTLVblen = function (b, a) {
+ return 2 + ASN1HEX.getLblen(b, a) * 2 + ASN1HEX.getVblen(b, a) * 2;
+};ASN1HEX.getNextSiblingIdx = function (d, a) {
+ var c = ASN1HEX.getVidx(d, a);var b = ASN1HEX.getVblen(d, a);return c + b * 2;
+};ASN1HEX.getChildIdx = function (e, k) {
+ var l = ASN1HEX;var j = [];var c, f, g;c = l.getVidx(e, k);f = l.getVblen(e, k) * 2;if (e.substr(k, 2) == "03") {
+ c += 2;f -= 2;
+ }g = 0;var d = c;while (g <= f) {
+ var b = l.getTLVblen(e, d);g += b;if (g <= f) {
+ j.push(d);
+ }d += b;if (g >= f) {
+ break;
+ }
+ }return j;
+};ASN1HEX.getNthChildIdx = function (d, b, e) {
+ var c = ASN1HEX.getChildIdx(d, b);return c[e];
+};ASN1HEX.getIdxbyList = function (e, d, c, i) {
+ var g = ASN1HEX;var f, b;if (c.length == 0) {
+ if (i !== undefined) {
+ if (e.substr(d, 2) !== i) {
+ return -1;
+ }
+ }return d;
+ }f = c.shift();b = g.getChildIdx(e, d);if (f >= b.length) {
+ return -1;
+ }return g.getIdxbyList(e, b[f], c, i);
+};ASN1HEX.getIdxbyListEx = function (f, k, b, g) {
+ var m = ASN1HEX;var d, l;if (b.length == 0) {
+ if (g !== undefined) {
+ if (f.substr(k, 2) !== g) {
+ return -1;
+ }
+ }return k;
+ }d = b.shift();l = m.getChildIdx(f, k);var j = 0;for (var e = 0; e < l.length; e++) {
+ var c = f.substr(l[e], 2);if (typeof d == "number" && !m.isContextTag(c) && j == d || typeof d == "string" && m.isContextTag(c, d)) {
+ return m.getIdxbyListEx(f, l[e], b, g);
+ }if (!m.isContextTag(c)) {
+ j++;
+ }
+ }return -1;
+};ASN1HEX.getTLVbyList = function (d, c, b, f) {
+ var e = ASN1HEX;var a = e.getIdxbyList(d, c, b, f);if (a == -1) {
+ return null;
+ }if (a >= d.length) {
+ return null;
+ }return e.getTLV(d, a);
+};ASN1HEX.getTLVbyListEx = function (d, c, b, f) {
+ var e = ASN1HEX;var a = e.getIdxbyListEx(d, c, b, f);if (a == -1) {
+ return null;
+ }return e.getTLV(d, a);
+};ASN1HEX.getVbyList = function (e, c, b, g, i) {
+ var f = ASN1HEX;var a, d;a = f.getIdxbyList(e, c, b, g);if (a == -1) {
+ return null;
+ }if (a >= e.length) {
+ return null;
+ }d = f.getV(e, a);if (i === true) {
+ d = d.substr(2);
+ }return d;
+};ASN1HEX.getVbyListEx = function (b, e, a, d, f) {
+ var j = ASN1HEX;var g, c, i;g = j.getIdxbyListEx(b, e, a, d);if (g == -1) {
+ return null;
+ }i = j.getV(b, g);if (b.substr(g, 2) == "03" && f !== false) {
+ i = i.substr(2);
+ }return i;
+};ASN1HEX.getInt = function (e, b, f) {
+ if (f == undefined) {
+ f = -1;
+ }try {
+ var c = e.substr(b, 2);if (c != "02" && c != "03") {
+ return f;
+ }var a = ASN1HEX.getV(e, b);if (c == "02") {
+ return parseInt(a, 16);
+ } else {
+ return bitstrtoint(a);
+ }
+ } catch (d) {
+ return f;
+ }
+};ASN1HEX.getOID = function (c, a, d) {
+ if (d == undefined) {
+ d = null;
+ }try {
+ if (c.substr(a, 2) != "06") {
+ return d;
+ }var e = ASN1HEX.getV(c, a);return hextooid(e);
+ } catch (b) {
+ return d;
+ }
+};ASN1HEX.getOIDName = function (d, a, f) {
+ if (f == undefined) {
+ f = null;
+ }try {
+ var e = ASN1HEX.getOID(d, a, f);if (e == f) {
+ return f;
+ }var b = KJUR.asn1.x509.OID.oid2name(e);if (b == "") {
+ return e;
+ }return b;
+ } catch (c) {
+ return f;
+ }
+};ASN1HEX.getString = function (d, b, e) {
+ if (e == undefined) {
+ e = null;
+ }try {
+ var a = ASN1HEX.getV(d, b);return hextorstr(a);
+ } catch (c) {
+ return e;
+ }
+};ASN1HEX.hextooidstr = function (e) {
+ var h = function h(b, a) {
+ if (b.length >= a) {
+ return b;
+ }return new Array(a - b.length + 1).join("0") + b;
+ };var l = [];var o = e.substr(0, 2);var f = parseInt(o, 16);l[0] = new String(Math.floor(f / 40));l[1] = new String(f % 40);var m = e.substr(2);var k = [];for (var g = 0; g < m.length / 2; g++) {
+ k.push(parseInt(m.substr(g * 2, 2), 16));
+ }var j = [];var d = "";for (var g = 0; g < k.length; g++) {
+ if (k[g] & 128) {
+ d = d + h((k[g] & 127).toString(2), 7);
+ } else {
+ d = d + h((k[g] & 127).toString(2), 7);j.push(new String(parseInt(d, 2)));d = "";
+ }
+ }var n = l.join(".");if (j.length > 0) {
+ n = n + "." + j.join(".");
+ }return n;
+};ASN1HEX.dump = function (t, c, l, g) {
+ var p = ASN1HEX;var j = p.getV;var y = p.dump;var w = p.getChildIdx;var e = t;if (t instanceof KJUR.asn1.ASN1Object) {
+ e = t.getEncodedHex();
+ }var q = function q(A, i) {
+ if (A.length <= i * 2) {
+ return A;
+ } else {
+ var v = A.substr(0, i) + "..(total " + A.length / 2 + "bytes).." + A.substr(A.length - i, i);return v;
+ }
+ };if (c === undefined) {
+ c = { ommit_long_octet: 32 };
+ }if (l === undefined) {
+ l = 0;
+ }if (g === undefined) {
+ g = "";
+ }var x = c.ommit_long_octet;var z = e.substr(l, 2);if (z == "01") {
+ var h = j(e, l);if (h == "00") {
+ return g + "BOOLEAN FALSE\n";
+ } else {
+ return g + "BOOLEAN TRUE\n";
+ }
+ }if (z == "02") {
+ var h = j(e, l);return g + "INTEGER " + q(h, x) + "\n";
+ }if (z == "03") {
+ var h = j(e, l);if (p.isASN1HEX(h.substr(2))) {
+ var k = g + "BITSTRING, encapsulates\n";k = k + y(h.substr(2), c, 0, g + " ");return k;
+ } else {
+ return g + "BITSTRING " + q(h, x) + "\n";
+ }
+ }if (z == "04") {
+ var h = j(e, l);if (p.isASN1HEX(h)) {
+ var k = g + "OCTETSTRING, encapsulates\n";k = k + y(h, c, 0, g + " ");return k;
+ } else {
+ return g + "OCTETSTRING " + q(h, x) + "\n";
+ }
+ }if (z == "05") {
+ return g + "NULL\n";
+ }if (z == "06") {
+ var m = j(e, l);var b = KJUR.asn1.ASN1Util.oidHexToInt(m);var o = KJUR.asn1.x509.OID.oid2name(b);var a = b.replace(/\./g, " ");if (o != "") {
+ return g + "ObjectIdentifier " + o + " (" + a + ")\n";
+ } else {
+ return g + "ObjectIdentifier (" + a + ")\n";
+ }
+ }if (z == "0a") {
+ return g + "ENUMERATED " + parseInt(j(e, l)) + "\n";
+ }if (z == "0c") {
+ return g + "UTF8String '" + hextoutf8(j(e, l)) + "'\n";
+ }if (z == "13") {
+ return g + "PrintableString '" + hextoutf8(j(e, l)) + "'\n";
+ }if (z == "14") {
+ return g + "TeletexString '" + hextoutf8(j(e, l)) + "'\n";
+ }if (z == "16") {
+ return g + "IA5String '" + hextoutf8(j(e, l)) + "'\n";
+ }if (z == "17") {
+ return g + "UTCTime " + hextoutf8(j(e, l)) + "\n";
+ }if (z == "18") {
+ return g + "GeneralizedTime " + hextoutf8(j(e, l)) + "\n";
+ }if (z == "1a") {
+ return g + "VisualString '" + hextoutf8(j(e, l)) + "'\n";
+ }if (z == "1e") {
+ return g + "BMPString '" + ucs2hextoutf8(j(e, l)) + "'\n";
+ }if (z == "30") {
+ if (e.substr(l, 4) == "3000") {
+ return g + "SEQUENCE {}\n";
+ }var k = g + "SEQUENCE\n";var d = w(e, l);var f = c;if ((d.length == 2 || d.length == 3) && e.substr(d[0], 2) == "06" && e.substr(d[d.length - 1], 2) == "04") {
+ var o = p.oidname(j(e, d[0]));var r = JSON.parse(JSON.stringify(c));r.x509ExtName = o;f = r;
+ }for (var u = 0; u < d.length; u++) {
+ k = k + y(e, f, d[u], g + " ");
+ }return k;
+ }if (z == "31") {
+ var k = g + "SET\n";var d = w(e, l);for (var u = 0; u < d.length; u++) {
+ k = k + y(e, c, d[u], g + " ");
+ }return k;
+ }var z = parseInt(z, 16);if ((z & 128) != 0) {
+ var n = z & 31;if ((z & 32) != 0) {
+ var k = g + "[" + n + "]\n";var d = w(e, l);for (var u = 0; u < d.length; u++) {
+ k = k + y(e, c, d[u], g + " ");
+ }return k;
+ } else {
+ var h = j(e, l);if (ASN1HEX.isASN1HEX(h)) {
+ var k = g + "[" + n + "]\n";k = k + y(h, c, 0, g + " ");return k;
+ } else {
+ if (h.substr(0, 8) == "68747470") {
+ h = hextoutf8(h);
+ } else {
+ if (c.x509ExtName === "subjectAltName" && n == 2) {
+ h = hextoutf8(h);
+ }
+ }
+ }var k = g + "[" + n + "] " + h + "\n";return k;
+ }
+ }return g + "UNKNOWN(" + z + ") " + j(e, l) + "\n";
+};ASN1HEX.isContextTag = function (c, b) {
+ c = c.toLowerCase();var f, e;try {
+ f = parseInt(c, 16);
+ } catch (d) {
+ return -1;
+ }if (b === undefined) {
+ if ((f & 192) == 128) {
+ return true;
+ } else {
+ return false;
+ }
+ }try {
+ var a = b.match(/^\[[0-9]+\]$/);if (a == null) {
+ return false;
+ }e = parseInt(b.substr(1, b.length - 1), 10);if (e > 31) {
+ return false;
+ }if ((f & 192) == 128 && (f & 31) == e) {
+ return true;
+ }return false;
+ } catch (d) {
+ return false;
+ }
+};ASN1HEX.isASN1HEX = function (e) {
+ var d = ASN1HEX;if (e.length % 2 == 1) {
+ return false;
+ }var c = d.getVblen(e, 0);var b = e.substr(0, 2);var f = d.getL(e, 0);var a = e.length - b.length - f.length;if (a == c * 2) {
+ return true;
+ }return false;
+};ASN1HEX.checkStrictDER = function (g, o, d, c, r) {
+ var s = ASN1HEX;if (d === undefined) {
+ if (typeof g != "string") {
+ throw new Error("not hex string");
+ }g = g.toLowerCase();if (!KJUR.lang.String.isHex(g)) {
+ throw new Error("not hex string");
+ }d = g.length;c = g.length / 2;if (c < 128) {
+ r = 1;
+ } else {
+ r = Math.ceil(c.toString(16)) + 1;
+ }
+ }var k = s.getL(g, o);if (k.length > r * 2) {
+ throw new Error("L of TLV too long: idx=" + o);
+ }var n = s.getVblen(g, o);if (n > c) {
+ throw new Error("value of L too long than hex: idx=" + o);
+ }var q = s.getTLV(g, o);var f = q.length - 2 - s.getL(g, o).length;if (f !== n * 2) {
+ throw new Error("V string length and L's value not the same:" + f + "/" + n * 2);
+ }if (o === 0) {
+ if (g.length != q.length) {
+ throw new Error("total length and TLV length unmatch:" + g.length + "!=" + q.length);
+ }
+ }var b = g.substr(o, 2);if (b === "02") {
+ var a = s.getVidx(g, o);if (g.substr(a, 2) == "00" && g.charCodeAt(a + 2) < 56) {
+ throw new Error("not least zeros for DER INTEGER");
+ }
+ }if (parseInt(b, 16) & 32) {
+ var p = s.getVblen(g, o);var m = 0;var l = s.getChildIdx(g, o);for (var e = 0; e < l.length; e++) {
+ var j = s.getTLV(g, l[e]);m += j.length;s.checkStrictDER(g, l[e], d, c, r);
+ }if (p * 2 != m) {
+ throw new Error("sum of children's TLV length and L unmatch: " + p * 2 + "!=" + m);
+ }
+ }
+};ASN1HEX.oidname = function (a) {
+ var c = KJUR.asn1;if (KJUR.lang.String.isHex(a)) {
+ a = c.ASN1Util.oidHexToInt(a);
+ }var b = c.x509.OID.oid2name(a);if (b === "") {
+ b = a;
+ }return b;
+};
+var KJUR;if (typeof KJUR == "undefined" || !KJUR) {
+ exports.KJUR = KJUR = {};
+}if (typeof KJUR.lang == "undefined" || !KJUR.lang) {
+ KJUR.lang = {};
+}KJUR.lang.String = function () {};function Base64x() {}function stoBA(d) {
+ var b = new Array();for (var c = 0; c < d.length; c++) {
+ b[c] = d.charCodeAt(c);
+ }return b;
+}function BAtos(b) {
+ var d = "";for (var c = 0; c < b.length; c++) {
+ d = d + String.fromCharCode(b[c]);
+ }return d;
+}function BAtohex(b) {
+ var e = "";for (var d = 0; d < b.length; d++) {
+ var c = b[d].toString(16);if (c.length == 1) {
+ c = "0" + c;
+ }e = e + c;
+ }return e;
+}function stohex(a) {
+ return BAtohex(stoBA(a));
+}function stob64(a) {
+ return hex2b64(stohex(a));
+}function stob64u(a) {
+ return b64tob64u(hex2b64(stohex(a)));
+}function b64utos(a) {
+ return BAtos(b64toBA(b64utob64(a)));
+}function b64tob64u(a) {
+ a = a.replace(/\=/g, "");a = a.replace(/\+/g, "-");a = a.replace(/\//g, "_");return a;
+}function b64utob64(a) {
+ if (a.length % 4 == 2) {
+ a = a + "==";
+ } else {
+ if (a.length % 4 == 3) {
+ a = a + "=";
+ }
+ }a = a.replace(/-/g, "+");a = a.replace(/_/g, "/");return a;
+}function hextob64u(a) {
+ if (a.length % 2 == 1) {
+ a = "0" + a;
+ }return b64tob64u(hex2b64(a));
+}function b64utohex(a) {
+ return b64tohex(b64utob64(a));
+}var utf8tob64u, b64utoutf8;if (typeof Buffer === "function") {
+ exports.utf8tob64u = utf8tob64u = function utf8tob64u(a) {
+ return b64tob64u(Buffer.from(a, "utf8").toString("base64"));
+ };exports.b64utoutf8 = b64utoutf8 = function b64utoutf8(a) {
+ return Buffer.from(b64utob64(a), "base64").toString("utf8");
+ };
+} else {
+ exports.utf8tob64u = utf8tob64u = function utf8tob64u(a) {
+ return hextob64u(uricmptohex(encodeURIComponentAll(a)));
+ };exports.b64utoutf8 = b64utoutf8 = function b64utoutf8(a) {
+ return decodeURIComponent(hextouricmp(b64utohex(a)));
+ };
+}function utf8tob64(a) {
+ return hex2b64(uricmptohex(encodeURIComponentAll(a)));
+}function b64toutf8(a) {
+ return decodeURIComponent(hextouricmp(b64tohex(a)));
+}function utf8tohex(a) {
+ return uricmptohex(encodeURIComponentAll(a));
+}function hextoutf8(a) {
+ return decodeURIComponent(hextouricmp(a));
+}function hextorstr(c) {
+ var b = "";for (var a = 0; a < c.length - 1; a += 2) {
+ b += String.fromCharCode(parseInt(c.substr(a, 2), 16));
+ }return b;
+}function rstrtohex(c) {
+ var a = "";for (var b = 0; b < c.length; b++) {
+ a += ("0" + c.charCodeAt(b).toString(16)).slice(-2);
+ }return a;
+}function hextob64(a) {
+ return hex2b64(a);
+}function hextob64nl(b) {
+ var a = hextob64(b);var c = a.replace(/(.{64})/g, "$1\r\n");c = c.replace(/\r\n$/, "");return c;
+}function b64nltohex(b) {
+ var a = b.replace(/[^0-9A-Za-z\/+=]*/g, "");var c = b64tohex(a);return c;
+}function hextopem(a, b) {
+ var c = hextob64nl(a);return "-----BEGIN " + b + "-----\r\n" + c + "\r\n-----END " + b + "-----\r\n";
+}function pemtohex(a, b) {
+ if (a.indexOf("-----BEGIN ") == -1) {
+ throw "can't find PEM header: " + b;
+ }if (b !== undefined) {
+ a = a.replace(new RegExp("^[^]*-----BEGIN " + b + "-----"), "");a = a.replace(new RegExp("-----END " + b + "-----[^]*$"), "");
+ } else {
+ a = a.replace(/^[^]*-----BEGIN [^-]+-----/, "");a = a.replace(/-----END [^-]+-----[^]*$/, "");
+ }return b64nltohex(a);
+}function hextoArrayBuffer(d) {
+ if (d.length % 2 != 0) {
+ throw "input is not even length";
+ }if (d.match(/^[0-9A-Fa-f]+$/) == null) {
+ throw "input is not hexadecimal";
+ }var b = new ArrayBuffer(d.length / 2);var a = new DataView(b);for (var c = 0; c < d.length / 2; c++) {
+ a.setUint8(c, parseInt(d.substr(c * 2, 2), 16));
+ }return b;
+}function ArrayBuffertohex(b) {
+ var d = "";var a = new DataView(b);for (var c = 0; c < b.byteLength; c++) {
+ d += ("00" + a.getUint8(c).toString(16)).slice(-2);
+ }return d;
+}function zulutomsec(n) {
+ var l, j, m, e, f, i, b, k;var a, h, g, c;c = n.match(/^(\d{2}|\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(|\.\d+)Z$/);if (c) {
+ a = c[1];l = parseInt(a);if (a.length === 2) {
+ if (50 <= l && l < 100) {
+ l = 1900 + l;
+ } else {
+ if (0 <= l && l < 50) {
+ l = 2000 + l;
+ }
+ }
+ }j = parseInt(c[2]) - 1;m = parseInt(c[3]);e = parseInt(c[4]);f = parseInt(c[5]);i = parseInt(c[6]);b = 0;h = c[7];if (h !== "") {
+ g = (h.substr(1) + "00").substr(0, 3);b = parseInt(g);
+ }return Date.UTC(l, j, m, e, f, i, b);
+ }throw "unsupported zulu format: " + n;
+}function zulutosec(a) {
+ var b = zulutomsec(a);return ~~(b / 1000);
+}function zulutodate(a) {
+ return new Date(zulutomsec(a));
+}function datetozulu(g, e, f) {
+ var b;var a = g.getUTCFullYear();if (e) {
+ if (a < 1950 || 2049 < a) {
+ throw "not proper year for UTCTime: " + a;
+ }b = ("" + a).slice(-2);
+ } else {
+ b = ("000" + a).slice(-4);
+ }b += ("0" + (g.getUTCMonth() + 1)).slice(-2);b += ("0" + g.getUTCDate()).slice(-2);b += ("0" + g.getUTCHours()).slice(-2);b += ("0" + g.getUTCMinutes()).slice(-2);b += ("0" + g.getUTCSeconds()).slice(-2);if (f) {
+ var c = g.getUTCMilliseconds();if (c !== 0) {
+ c = ("00" + c).slice(-3);c = c.replace(/0+$/g, "");b += "." + c;
+ }
+ }b += "Z";return b;
+}function uricmptohex(a) {
+ return a.replace(/%/g, "");
+}function hextouricmp(a) {
+ return a.replace(/(..)/g, "%$1");
+}function ipv6tohex(g) {
+ var b = "malformed IPv6 address";if (!g.match(/^[0-9A-Fa-f:]+$/)) {
+ throw b;
+ }g = g.toLowerCase();var d = g.split(":").length - 1;if (d < 2) {
+ throw b;
+ }var e = ":".repeat(7 - d + 2);g = g.replace("::", e);var c = g.split(":");if (c.length != 8) {
+ throw b;
+ }for (var f = 0; f < 8; f++) {
+ c[f] = ("0000" + c[f]).slice(-4);
+ }return c.join("");
+}function hextoipv6(e) {
+ if (!e.match(/^[0-9A-Fa-f]{32}$/)) {
+ throw "malformed IPv6 address octet";
+ }e = e.toLowerCase();var b = e.match(/.{1,4}/g);for (var d = 0; d < 8; d++) {
+ b[d] = b[d].replace(/^0+/, "");if (b[d] == "") {
+ b[d] = "0";
+ }
+ }e = ":" + b.join(":") + ":";var c = e.match(/:(0:){2,}/g);if (c === null) {
+ return e.slice(1, -1);
+ }var f = "";for (var d = 0; d < c.length; d++) {
+ if (c[d].length > f.length) {
+ f = c[d];
+ }
+ }e = e.replace(f, "::");return e.slice(1, -1);
+}function hextoip(b) {
+ var d = "malformed hex value";if (!b.match(/^([0-9A-Fa-f][0-9A-Fa-f]){1,}$/)) {
+ throw d;
+ }if (b.length == 8) {
+ var c;try {
+ c = parseInt(b.substr(0, 2), 16) + "." + parseInt(b.substr(2, 2), 16) + "." + parseInt(b.substr(4, 2), 16) + "." + parseInt(b.substr(6, 2), 16);return c;
+ } catch (a) {
+ throw d;
+ }
+ } else {
+ if (b.length == 32) {
+ return hextoipv6(b);
+ } else {
+ return b;
+ }
+ }
+}function iptohex(f) {
+ var j = "malformed IP address";f = f.toLowerCase(f);if (f.match(/^[0-9.]+$/)) {
+ var b = f.split(".");if (b.length !== 4) {
+ throw j;
+ }var g = "";try {
+ for (var e = 0; e < 4; e++) {
+ var h = parseInt(b[e]);g += ("0" + h.toString(16)).slice(-2);
+ }return g;
+ } catch (c) {
+ throw j;
+ }
+ } else {
+ if (f.match(/^[0-9a-f:]+$/) && f.indexOf(":") !== -1) {
+ return ipv6tohex(f);
+ } else {
+ throw j;
+ }
+ }
+}function ucs2hextoutf8(d) {
+ function e(f) {
+ var h = parseInt(f.substr(0, 2), 16);var a = parseInt(f.substr(2), 16);if (h == 0 & a < 128) {
+ return String.fromCharCode(a);
+ }if (h < 8) {
+ var j = 192 | (h & 7) << 3 | (a & 192) >> 6;var i = 128 | a & 63;return hextoutf8(j.toString(16) + i.toString(16));
+ }var j = 224 | (h & 240) >> 4;var i = 128 | (h & 15) << 2 | (a & 192) >> 6;var g = 128 | a & 63;return hextoutf8(j.toString(16) + i.toString(16) + g.toString(16));
+ }var c = d.match(/.{4}/g);var b = c.map(e);return b.join("");
+}function encodeURIComponentAll(a) {
+ var d = encodeURIComponent(a);var b = "";for (var c = 0; c < d.length; c++) {
+ if (d[c] == "%") {
+ b = b + d.substr(c, 3);c = c + 2;
+ } else {
+ b = b + "%" + stohex(d[c]);
+ }
+ }return b;
+}function newline_toUnix(a) {
+ a = a.replace(/\r\n/mg, "\n");return a;
+}function newline_toDos(a) {
+ a = a.replace(/\r\n/mg, "\n");a = a.replace(/\n/mg, "\r\n");return a;
+}KJUR.lang.String.isInteger = function (a) {
+ if (a.match(/^[0-9]+$/)) {
+ return true;
+ } else {
+ if (a.match(/^-[0-9]+$/)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+};KJUR.lang.String.isHex = function (a) {
+ return ishex(a);
+};function ishex(a) {
+ if (a.length % 2 == 0 && (a.match(/^[0-9a-f]+$/) || a.match(/^[0-9A-F]+$/))) {
+ return true;
+ } else {
+ return false;
+ }
+}KJUR.lang.String.isBase64 = function (a) {
+ a = a.replace(/\s+/g, "");if (a.match(/^[0-9A-Za-z+\/]+={0,3}$/) && a.length % 4 == 0) {
+ return true;
+ } else {
+ return false;
+ }
+};KJUR.lang.String.isBase64URL = function (a) {
+ if (a.match(/[+/=]/)) {
+ return false;
+ }a = b64utob64(a);return KJUR.lang.String.isBase64(a);
+};KJUR.lang.String.isIntegerArray = function (a) {
+ a = a.replace(/\s+/g, "");if (a.match(/^\[[0-9,]+\]$/)) {
+ return true;
+ } else {
+ return false;
+ }
+};KJUR.lang.String.isPrintable = function (a) {
+ if (a.match(/^[0-9A-Za-z '()+,-./:=?]*$/) !== null) {
+ return true;
+ }return false;
+};KJUR.lang.String.isIA5 = function (a) {
+ if (a.match(/^[\x20-\x21\x23-\x7f]*$/) !== null) {
+ return true;
+ }return false;
+};KJUR.lang.String.isMail = function (a) {
+ if (a.match(/^[A-Za-z0-9]{1}[A-Za-z0-9_.-]*@{1}[A-Za-z0-9_.-]{1,}\.[A-Za-z0-9]{1,}$/) !== null) {
+ return true;
+ }return false;
+};function hextoposhex(a) {
+ if (a.length % 2 == 1) {
+ return "0" + a;
+ }if (a.substr(0, 1) > "7") {
+ return "00" + a;
+ }return a;
+}function intarystrtohex(b) {
+ b = b.replace(/^\s*\[\s*/, "");b = b.replace(/\s*\]\s*$/, "");b = b.replace(/\s*/g, "");try {
+ var c = b.split(/,/).map(function (g, e, h) {
+ var f = parseInt(g);if (f < 0 || 255 < f) {
+ throw "integer not in range 0-255";
+ }var d = ("00" + f.toString(16)).slice(-2);return d;
+ }).join("");return c;
+ } catch (a) {
+ throw "malformed integer array string: " + a;
+ }
+}var strdiffidx = function strdiffidx(c, a) {
+ var d = c.length;if (c.length > a.length) {
+ d = a.length;
+ }for (var b = 0; b < d; b++) {
+ if (c.charCodeAt(b) != a.charCodeAt(b)) {
+ return b;
+ }
+ }if (c.length != a.length) {
+ return d;
+ }return -1;
+};function oidtohex(g) {
+ var f = function f(a) {
+ var l = a.toString(16);if (l.length == 1) {
+ l = "0" + l;
+ }return l;
+ };var e = function e(p) {
+ var o = "";var l = parseInt(p, 10);var a = l.toString(2);var m = 7 - a.length % 7;if (m == 7) {
+ m = 0;
+ }var r = "";for (var n = 0; n < m; n++) {
+ r += "0";
+ }a = r + a;for (var n = 0; n < a.length - 1; n += 7) {
+ var q = a.substr(n, 7);if (n != a.length - 7) {
+ q = "1" + q;
+ }o += f(parseInt(q, 2));
+ }return o;
+ };try {
+ if (!g.match(/^[0-9.]+$/)) {
+ return null;
+ }var j = "";var b = g.split(".");var k = parseInt(b[0], 10) * 40 + parseInt(b[1], 10);j += f(k);b.splice(0, 2);for (var d = 0; d < b.length; d++) {
+ j += e(b[d]);
+ }return j;
+ } catch (c) {
+ return null;
+ }
+}function hextooid(g) {
+ if (!ishex(g)) {
+ return null;
+ }try {
+ var m = [];var p = g.substr(0, 2);var e = parseInt(p, 16);m[0] = new String(Math.floor(e / 40));m[1] = new String(e % 40);var n = g.substr(2);var l = [];for (var f = 0; f < n.length / 2; f++) {
+ l.push(parseInt(n.substr(f * 2, 2), 16));
+ }var k = [];var d = "";for (var f = 0; f < l.length; f++) {
+ if (l[f] & 128) {
+ d = d + strpad((l[f] & 127).toString(2), 7);
+ } else {
+ d = d + strpad((l[f] & 127).toString(2), 7);k.push(new String(parseInt(d, 2)));d = "";
+ }
+ }var o = m.join(".");if (k.length > 0) {
+ o = o + "." + k.join(".");
+ }return o;
+ } catch (j) {
+ return null;
+ }
+}var strpad = function strpad(c, b, a) {
+ if (a == undefined) {
+ a = "0";
+ }if (c.length >= b) {
+ return c;
+ }return new Array(b - c.length + 1).join(a) + c;
+};function bitstrtoint(e) {
+ try {
+ var a = e.substr(0, 2);if (a == "00") {
+ return parseInt(e.substr(2), 16);
+ }var b = parseInt(a, 16);var f = e.substr(2);var d = parseInt(f, 16).toString(2);if (d == "0") {
+ d = "00000000";
+ }d = d.slice(0, 0 - b);return parseInt(d, 2);
+ } catch (c) {
+ return -1;
+ }
+}function inttobitstr(e) {
+ var c = Number(e).toString(2);var b = 8 - c.length % 8;if (b == 8) {
+ b = 0;
+ }c = c + strpad("", b, "0");var d = parseInt(c, 2).toString(16);if (d.length % 2 == 1) {
+ d = "0" + d;
+ }var a = "0" + b;return a + d;
+}function extendClass(c, a) {
+ var b = function b() {};b.prototype = a.prototype;c.prototype = new b();c.prototype.constructor = c;c.superclass = a.prototype;if (a.prototype.constructor == Object.prototype.constructor) {
+ a.prototype.constructor = a;
+ }
+};
+if (typeof KJUR == "undefined" || !KJUR) {
+ exports.KJUR = KJUR = {};
+}if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}KJUR.crypto.Util = new function () {
+ this.DIGESTINFOHEAD = { sha1: "3021300906052b0e03021a05000414", sha224: "302d300d06096086480165030402040500041c", sha256: "3031300d060960864801650304020105000420", sha384: "3041300d060960864801650304020205000430", sha512: "3051300d060960864801650304020305000440", md2: "3020300c06082a864886f70d020205000410", md5: "3020300c06082a864886f70d020505000410", ripemd160: "3021300906052b2403020105000414" };this.DEFAULTPROVIDER = { md5: "cryptojs", sha1: "cryptojs", sha224: "cryptojs", sha256: "cryptojs", sha384: "cryptojs", sha512: "cryptojs", ripemd160: "cryptojs", hmacmd5: "cryptojs", hmacsha1: "cryptojs", hmacsha224: "cryptojs", hmacsha256: "cryptojs", hmacsha384: "cryptojs", hmacsha512: "cryptojs", hmacripemd160: "cryptojs", MD5withRSA: "cryptojs/jsrsa", SHA1withRSA: "cryptojs/jsrsa", SHA224withRSA: "cryptojs/jsrsa", SHA256withRSA: "cryptojs/jsrsa", SHA384withRSA: "cryptojs/jsrsa", SHA512withRSA: "cryptojs/jsrsa", RIPEMD160withRSA: "cryptojs/jsrsa", MD5withECDSA: "cryptojs/jsrsa", SHA1withECDSA: "cryptojs/jsrsa", SHA224withECDSA: "cryptojs/jsrsa", SHA256withECDSA: "cryptojs/jsrsa", SHA384withECDSA: "cryptojs/jsrsa", SHA512withECDSA: "cryptojs/jsrsa", RIPEMD160withECDSA: "cryptojs/jsrsa", SHA1withDSA: "cryptojs/jsrsa", SHA224withDSA: "cryptojs/jsrsa", SHA256withDSA: "cryptojs/jsrsa", MD5withRSAandMGF1: "cryptojs/jsrsa", SHAwithRSAandMGF1: "cryptojs/jsrsa", SHA1withRSAandMGF1: "cryptojs/jsrsa", SHA224withRSAandMGF1: "cryptojs/jsrsa", SHA256withRSAandMGF1: "cryptojs/jsrsa", SHA384withRSAandMGF1: "cryptojs/jsrsa", SHA512withRSAandMGF1: "cryptojs/jsrsa", RIPEMD160withRSAandMGF1: "cryptojs/jsrsa" };this.CRYPTOJSMESSAGEDIGESTNAME = { md5: CryptoJS.algo.MD5, sha1: CryptoJS.algo.SHA1, sha224: CryptoJS.algo.SHA224, sha256: CryptoJS.algo.SHA256, sha384: CryptoJS.algo.SHA384, sha512: CryptoJS.algo.SHA512, ripemd160: CryptoJS.algo.RIPEMD160 };this.getDigestInfoHex = function (a, b) {
+ if (typeof this.DIGESTINFOHEAD[b] == "undefined") {
+ throw "alg not supported in Util.DIGESTINFOHEAD: " + b;
+ }return this.DIGESTINFOHEAD[b] + a;
+ };this.getPaddedDigestInfoHex = function (h, a, j) {
+ var c = this.getDigestInfoHex(h, a);var d = j / 4;if (c.length + 22 > d) {
+ throw "key is too short for SigAlg: keylen=" + j + "," + a;
+ }var b = "0001";var k = "00" + c;var g = "";var l = d - b.length - k.length;for (var f = 0; f < l; f += 2) {
+ g += "ff";
+ }var e = b + g + k;return e;
+ };this.hashString = function (a, c) {
+ var b = new KJUR.crypto.MessageDigest({ alg: c });return b.digestString(a);
+ };this.hashHex = function (b, c) {
+ var a = new KJUR.crypto.MessageDigest({ alg: c });return a.digestHex(b);
+ };this.sha1 = function (a) {
+ return this.hashString(a, "sha1");
+ };this.sha256 = function (a) {
+ return this.hashString(a, "sha256");
+ };this.sha256Hex = function (a) {
+ return this.hashHex(a, "sha256");
+ };this.sha512 = function (a) {
+ return this.hashString(a, "sha512");
+ };this.sha512Hex = function (a) {
+ return this.hashHex(a, "sha512");
+ };this.isKey = function (a) {
+ if (a instanceof RSAKey || a instanceof KJUR.crypto.DSA || a instanceof KJUR.crypto.ECDSA) {
+ return true;
+ } else {
+ return false;
+ }
+ };
+}();KJUR.crypto.Util.md5 = function (a) {
+ var b = new KJUR.crypto.MessageDigest({ alg: "md5", prov: "cryptojs" });return b.digestString(a);
+};KJUR.crypto.Util.ripemd160 = function (a) {
+ var b = new KJUR.crypto.MessageDigest({ alg: "ripemd160", prov: "cryptojs" });return b.digestString(a);
+};KJUR.crypto.Util.SECURERANDOMGEN = new SecureRandom();KJUR.crypto.Util.getRandomHexOfNbytes = function (b) {
+ var a = new Array(b);KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(a);return BAtohex(a);
+};KJUR.crypto.Util.getRandomBigIntegerOfNbytes = function (a) {
+ return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbytes(a), 16);
+};KJUR.crypto.Util.getRandomHexOfNbits = function (d) {
+ var c = d % 8;var a = (d - c) / 8;var b = new Array(a + 1);KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(b);b[0] = (255 << c & 255 ^ 255) & b[0];return BAtohex(b);
+};KJUR.crypto.Util.getRandomBigIntegerOfNbits = function (a) {
+ return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbits(a), 16);
+};KJUR.crypto.Util.getRandomBigIntegerZeroToMax = function (b) {
+ var a = b.bitLength();while (1) {
+ var c = KJUR.crypto.Util.getRandomBigIntegerOfNbits(a);if (b.compareTo(c) != -1) {
+ return c;
+ }
+ }
+};KJUR.crypto.Util.getRandomBigIntegerMinToMax = function (e, b) {
+ var c = e.compareTo(b);if (c == 1) {
+ throw "biMin is greater than biMax";
+ }if (c == 0) {
+ return e;
+ }var a = b.subtract(e);var d = KJUR.crypto.Util.getRandomBigIntegerZeroToMax(a);return d.add(e);
+};KJUR.crypto.MessageDigest = function (c) {
+ var b = null;var a = null;var d = null;this.setAlgAndProvider = function (g, f) {
+ g = KJUR.crypto.MessageDigest.getCanonicalAlgName(g);if (g !== null && f === undefined) {
+ f = KJUR.crypto.Util.DEFAULTPROVIDER[g];
+ }if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(g) != -1 && f == "cryptojs") {
+ try {
+ this.md = KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[g].create();
+ } catch (e) {
+ throw "setAlgAndProvider hash alg set fail alg=" + g + "/" + e;
+ }this.updateString = function (h) {
+ this.md.update(h);
+ };this.updateHex = function (h) {
+ var i = CryptoJS.enc.Hex.parse(h);this.md.update(i);
+ };this.digest = function () {
+ var h = this.md.finalize();return h.toString(CryptoJS.enc.Hex);
+ };this.digestString = function (h) {
+ this.updateString(h);return this.digest();
+ };this.digestHex = function (h) {
+ this.updateHex(h);return this.digest();
+ };
+ }if (":sha256:".indexOf(g) != -1 && f == "sjcl") {
+ try {
+ this.md = new sjcl.hash.sha256();
+ } catch (e) {
+ throw "setAlgAndProvider hash alg set fail alg=" + g + "/" + e;
+ }this.updateString = function (h) {
+ this.md.update(h);
+ };this.updateHex = function (i) {
+ var h = sjcl.codec.hex.toBits(i);this.md.update(h);
+ };this.digest = function () {
+ var h = this.md.finalize();return sjcl.codec.hex.fromBits(h);
+ };this.digestString = function (h) {
+ this.updateString(h);return this.digest();
+ };this.digestHex = function (h) {
+ this.updateHex(h);return this.digest();
+ };
+ }
+ };this.updateString = function (e) {
+ throw "updateString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };this.updateHex = function (e) {
+ throw "updateHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };this.digest = function () {
+ throw "digest() not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };this.digestString = function (e) {
+ throw "digestString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };this.digestHex = function (e) {
+ throw "digestHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };if (c !== undefined) {
+ if (c.alg !== undefined) {
+ this.algName = c.alg;if (c.prov === undefined) {
+ this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
+ }this.setAlgAndProvider(this.algName, this.provName);
+ }
+ }
+};KJUR.crypto.MessageDigest.getCanonicalAlgName = function (a) {
+ if (typeof a === "string") {
+ a = a.toLowerCase();a = a.replace(/-/, "");
+ }return a;
+};KJUR.crypto.MessageDigest.getHashLength = function (c) {
+ var b = KJUR.crypto.MessageDigest;var a = b.getCanonicalAlgName(c);if (b.HASHLENGTH[a] === undefined) {
+ throw "not supported algorithm: " + c;
+ }return b.HASHLENGTH[a];
+};KJUR.crypto.MessageDigest.HASHLENGTH = { md5: 16, sha1: 20, sha224: 28, sha256: 32, sha384: 48, sha512: 64, ripemd160: 20 };KJUR.crypto.Mac = function (d) {
+ var f = null;var c = null;var a = null;var e = null;var b = null;this.setAlgAndProvider = function (k, i) {
+ k = k.toLowerCase();if (k == null) {
+ k = "hmacsha1";
+ }k = k.toLowerCase();if (k.substr(0, 4) != "hmac") {
+ throw "setAlgAndProvider unsupported HMAC alg: " + k;
+ }if (i === undefined) {
+ i = KJUR.crypto.Util.DEFAULTPROVIDER[k];
+ }this.algProv = k + "/" + i;var g = k.substr(4);if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(g) != -1 && i == "cryptojs") {
+ try {
+ var j = KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[g];this.mac = CryptoJS.algo.HMAC.create(j, this.pass);
+ } catch (h) {
+ throw "setAlgAndProvider hash alg set fail hashAlg=" + g + "/" + h;
+ }this.updateString = function (l) {
+ this.mac.update(l);
+ };this.updateHex = function (l) {
+ var m = CryptoJS.enc.Hex.parse(l);this.mac.update(m);
+ };this.doFinal = function () {
+ var l = this.mac.finalize();return l.toString(CryptoJS.enc.Hex);
+ };this.doFinalString = function (l) {
+ this.updateString(l);return this.doFinal();
+ };this.doFinalHex = function (l) {
+ this.updateHex(l);return this.doFinal();
+ };
+ }
+ };this.updateString = function (g) {
+ throw "updateString(str) not supported for this alg/prov: " + this.algProv;
+ };this.updateHex = function (g) {
+ throw "updateHex(hex) not supported for this alg/prov: " + this.algProv;
+ };this.doFinal = function () {
+ throw "digest() not supported for this alg/prov: " + this.algProv;
+ };this.doFinalString = function (g) {
+ throw "digestString(str) not supported for this alg/prov: " + this.algProv;
+ };this.doFinalHex = function (g) {
+ throw "digestHex(hex) not supported for this alg/prov: " + this.algProv;
+ };this.setPassword = function (h) {
+ if (typeof h == "string") {
+ var g = h;if (h.length % 2 == 1 || !h.match(/^[0-9A-Fa-f]+$/)) {
+ g = rstrtohex(h);
+ }this.pass = CryptoJS.enc.Hex.parse(g);return;
+ }if ((typeof h === "undefined" ? "undefined" : _typeof(h)) != "object") {
+ throw "KJUR.crypto.Mac unsupported password type: " + h;
+ }var g = null;if (h.hex !== undefined) {
+ if (h.hex.length % 2 != 0 || !h.hex.match(/^[0-9A-Fa-f]+$/)) {
+ throw "Mac: wrong hex password: " + h.hex;
+ }g = h.hex;
+ }if (h.utf8 !== undefined) {
+ g = utf8tohex(h.utf8);
+ }if (h.rstr !== undefined) {
+ g = rstrtohex(h.rstr);
+ }if (h.b64 !== undefined) {
+ g = b64tohex(h.b64);
+ }if (h.b64u !== undefined) {
+ g = b64utohex(h.b64u);
+ }if (g == null) {
+ throw "KJUR.crypto.Mac unsupported password type: " + h;
+ }this.pass = CryptoJS.enc.Hex.parse(g);
+ };if (d !== undefined) {
+ if (d.pass !== undefined) {
+ this.setPassword(d.pass);
+ }if (d.alg !== undefined) {
+ this.algName = d.alg;if (d.prov === undefined) {
+ this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
+ }this.setAlgAndProvider(this.algName, this.provName);
+ }
+ }
+};KJUR.crypto.Signature = function (o) {
+ var q = null;var n = null;var r = null;var c = null;var l = null;var d = null;var k = null;var h = null;var p = null;var e = null;var b = -1;var g = null;var j = null;var a = null;var i = null;var f = null;this._setAlgNames = function () {
+ var s = this.algName.match(/^(.+)with(.+)$/);if (s) {
+ this.mdAlgName = s[1].toLowerCase();this.pubkeyAlgName = s[2].toLowerCase();if (this.pubkeyAlgName == "rsaandmgf1" && this.mdAlgName == "sha") {
+ this.mdAlgName = "sha1";
+ }
+ }
+ };this._zeroPaddingOfSignature = function (x, w) {
+ var v = "";var t = w / 4 - x.length;for (var u = 0; u < t; u++) {
+ v = v + "0";
+ }return v + x;
+ };this.setAlgAndProvider = function (u, t) {
+ this._setAlgNames();if (t != "cryptojs/jsrsa") {
+ throw new Error("provider not supported: " + t);
+ }if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(this.mdAlgName) != -1) {
+ try {
+ this.md = new KJUR.crypto.MessageDigest({ alg: this.mdAlgName });
+ } catch (s) {
+ throw new Error("setAlgAndProvider hash alg set fail alg=" + this.mdAlgName + "/" + s);
+ }this.init = function (w, x) {
+ var y = null;try {
+ if (x === undefined) {
+ y = KEYUTIL.getKey(w);
+ } else {
+ y = KEYUTIL.getKey(w, x);
+ }
+ } catch (v) {
+ throw "init failed:" + v;
+ }if (y.isPrivate === true) {
+ this.prvKey = y;this.state = "SIGN";
+ } else {
+ if (y.isPublic === true) {
+ this.pubKey = y;this.state = "VERIFY";
+ } else {
+ throw "init failed.:" + y;
+ }
+ }
+ };this.updateString = function (v) {
+ this.md.updateString(v);
+ };this.updateHex = function (v) {
+ this.md.updateHex(v);
+ };this.sign = function () {
+ this.sHashHex = this.md.digest();if (this.prvKey === undefined && this.ecprvhex !== undefined && this.eccurvename !== undefined && KJUR.crypto.ECDSA !== undefined) {
+ this.prvKey = new KJUR.crypto.ECDSA({ curve: this.eccurvename, prv: this.ecprvhex });
+ }if (this.prvKey instanceof RSAKey && this.pubkeyAlgName === "rsaandmgf1") {
+ this.hSign = this.prvKey.signWithMessageHashPSS(this.sHashHex, this.mdAlgName, this.pssSaltLen);
+ } else {
+ if (this.prvKey instanceof RSAKey && this.pubkeyAlgName === "rsa") {
+ this.hSign = this.prvKey.signWithMessageHash(this.sHashHex, this.mdAlgName);
+ } else {
+ if (this.prvKey instanceof KJUR.crypto.ECDSA) {
+ this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);
+ } else {
+ if (this.prvKey instanceof KJUR.crypto.DSA) {
+ this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);
+ } else {
+ throw "Signature: unsupported private key alg: " + this.pubkeyAlgName;
+ }
+ }
+ }
+ }return this.hSign;
+ };this.signString = function (v) {
+ this.updateString(v);return this.sign();
+ };this.signHex = function (v) {
+ this.updateHex(v);return this.sign();
+ };this.verify = function (v) {
+ this.sHashHex = this.md.digest();if (this.pubKey === undefined && this.ecpubhex !== undefined && this.eccurvename !== undefined && KJUR.crypto.ECDSA !== undefined) {
+ this.pubKey = new KJUR.crypto.ECDSA({ curve: this.eccurvename, pub: this.ecpubhex });
+ }if (this.pubKey instanceof RSAKey && this.pubkeyAlgName === "rsaandmgf1") {
+ return this.pubKey.verifyWithMessageHashPSS(this.sHashHex, v, this.mdAlgName, this.pssSaltLen);
+ } else {
+ if (this.pubKey instanceof RSAKey && this.pubkeyAlgName === "rsa") {
+ return this.pubKey.verifyWithMessageHash(this.sHashHex, v);
+ } else {
+ if (KJUR.crypto.ECDSA !== undefined && this.pubKey instanceof KJUR.crypto.ECDSA) {
+ return this.pubKey.verifyWithMessageHash(this.sHashHex, v);
+ } else {
+ if (KJUR.crypto.DSA !== undefined && this.pubKey instanceof KJUR.crypto.DSA) {
+ return this.pubKey.verifyWithMessageHash(this.sHashHex, v);
+ } else {
+ throw "Signature: unsupported public key alg: " + this.pubkeyAlgName;
+ }
+ }
+ }
+ }
+ };
+ }
+ };this.init = function (s, t) {
+ throw "init(key, pass) not supported for this alg:prov=" + this.algProvName;
+ };this.updateString = function (s) {
+ throw "updateString(str) not supported for this alg:prov=" + this.algProvName;
+ };this.updateHex = function (s) {
+ throw "updateHex(hex) not supported for this alg:prov=" + this.algProvName;
+ };this.sign = function () {
+ throw "sign() not supported for this alg:prov=" + this.algProvName;
+ };this.signString = function (s) {
+ throw "digestString(str) not supported for this alg:prov=" + this.algProvName;
+ };this.signHex = function (s) {
+ throw "digestHex(hex) not supported for this alg:prov=" + this.algProvName;
+ };this.verify = function (s) {
+ throw "verify(hSigVal) not supported for this alg:prov=" + this.algProvName;
+ };this.initParams = o;if (o !== undefined) {
+ if (o.alg !== undefined) {
+ this.algName = o.alg;if (o.prov === undefined) {
+ this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
+ } else {
+ this.provName = o.prov;
+ }this.algProvName = this.algName + ":" + this.provName;this.setAlgAndProvider(this.algName, this.provName);this._setAlgNames();
+ }if (o.psssaltlen !== undefined) {
+ this.pssSaltLen = o.psssaltlen;
+ }if (o.prvkeypem !== undefined) {
+ if (o.prvkeypas !== undefined) {
+ throw "both prvkeypem and prvkeypas parameters not supported";
+ } else {
+ try {
+ var q = KEYUTIL.getKey(o.prvkeypem);this.init(q);
+ } catch (m) {
+ throw "fatal error to load pem private key: " + m;
+ }
+ }
+ }
+ }
+};KJUR.crypto.Cipher = function (a) {};KJUR.crypto.Cipher.encrypt = function (e, f, d) {
+ if (f instanceof RSAKey && f.isPublic) {
+ var c = KJUR.crypto.Cipher.getAlgByKeyAndName(f, d);if (c === "RSA") {
+ return f.encrypt(e);
+ }if (c === "RSAOAEP") {
+ return f.encryptOAEP(e, "sha1");
+ }var b = c.match(/^RSAOAEP(\d+)$/);if (b !== null) {
+ return f.encryptOAEP(e, "sha" + b[1]);
+ }throw "Cipher.encrypt: unsupported algorithm for RSAKey: " + d;
+ } else {
+ throw "Cipher.encrypt: unsupported key or algorithm";
+ }
+};KJUR.crypto.Cipher.decrypt = function (e, f, d) {
+ if (f instanceof RSAKey && f.isPrivate) {
+ var c = KJUR.crypto.Cipher.getAlgByKeyAndName(f, d);if (c === "RSA") {
+ return f.decrypt(e);
+ }if (c === "RSAOAEP") {
+ return f.decryptOAEP(e, "sha1");
+ }var b = c.match(/^RSAOAEP(\d+)$/);if (b !== null) {
+ return f.decryptOAEP(e, "sha" + b[1]);
+ }throw "Cipher.decrypt: unsupported algorithm for RSAKey: " + d;
+ } else {
+ throw "Cipher.decrypt: unsupported key or algorithm";
+ }
+};KJUR.crypto.Cipher.getAlgByKeyAndName = function (b, a) {
+ if (b instanceof RSAKey) {
+ if (":RSA:RSAOAEP:RSAOAEP224:RSAOAEP256:RSAOAEP384:RSAOAEP512:".indexOf(a) != -1) {
+ return a;
+ }if (a === null || a === undefined) {
+ return "RSA";
+ }throw "getAlgByKeyAndName: not supported algorithm name for RSAKey: " + a;
+ }throw "getAlgByKeyAndName: not supported algorithm name: " + a;
+};KJUR.crypto.OID = new function () {
+ this.oidhex2name = { "2a864886f70d010101": "rsaEncryption", "2a8648ce3d0201": "ecPublicKey", "2a8648ce380401": "dsa", "2a8648ce3d030107": "secp256r1", "2b8104001f": "secp192k1", "2b81040021": "secp224r1", "2b8104000a": "secp256k1", "2b81040023": "secp521r1", "2b81040022": "secp384r1", "2a8648ce380403": "SHA1withDSA", "608648016503040301": "SHA224withDSA", "608648016503040302": "SHA256withDSA" };
+}();
+if (typeof KJUR == "undefined" || !KJUR) {
+ exports.KJUR = KJUR = {};
+}if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}KJUR.crypto.ECDSA = function (e) {
+ var g = "secp256r1";var p = null;var b = null;var i = null;var j = Error,
+ f = BigInteger,
+ h = ECPointFp,
+ m = KJUR.crypto.ECDSA,
+ c = KJUR.crypto.ECParameterDB,
+ d = m.getName,
+ q = ASN1HEX,
+ n = q.getVbyListEx,
+ k = q.isASN1HEX;var a = new SecureRandom();var o = null;this.type = "EC";this.isPrivate = false;this.isPublic = false;function l(x, t, w, s) {
+ var r = Math.max(t.bitLength(), s.bitLength());var y = x.add2D(w);var v = x.curve.getInfinity();for (var u = r - 1; u >= 0; --u) {
+ v = v.twice2D();v.z = f.ONE;if (t.testBit(u)) {
+ if (s.testBit(u)) {
+ v = v.add2D(y);
+ } else {
+ v = v.add2D(x);
+ }
+ } else {
+ if (s.testBit(u)) {
+ v = v.add2D(w);
+ }
+ }
+ }return v;
+ }this.getBigRandom = function (r) {
+ return new f(r.bitLength(), a).mod(r.subtract(f.ONE)).add(f.ONE);
+ };this.setNamedCurve = function (r) {
+ this.ecparams = c.getByName(r);this.prvKeyHex = null;this.pubKeyHex = null;this.curveName = r;
+ };this.setPrivateKeyHex = function (r) {
+ this.isPrivate = true;this.prvKeyHex = r;
+ };this.setPublicKeyHex = function (r) {
+ this.isPublic = true;this.pubKeyHex = r;
+ };this.getPublicKeyXYHex = function () {
+ var t = this.pubKeyHex;if (t.substr(0, 2) !== "04") {
+ throw "this method supports uncompressed format(04) only";
+ }var s = this.ecparams.keylen / 4;if (t.length !== 2 + s * 2) {
+ throw "malformed public key hex length";
+ }var r = {};r.x = t.substr(2, s);r.y = t.substr(2 + s);return r;
+ };this.getShortNISTPCurveName = function () {
+ var r = this.curveName;if (r === "secp256r1" || r === "NIST P-256" || r === "P-256" || r === "prime256v1") {
+ return "P-256";
+ }if (r === "secp384r1" || r === "NIST P-384" || r === "P-384") {
+ return "P-384";
+ }return null;
+ };this.generateKeyPairHex = function () {
+ var t = this.ecparams.n;var w = this.getBigRandom(t);var u = this.ecparams.G.multiply(w);var z = u.getX().toBigInteger();var x = u.getY().toBigInteger();var r = this.ecparams.keylen / 4;var v = ("0000000000" + w.toString(16)).slice(-r);var A = ("0000000000" + z.toString(16)).slice(-r);var y = ("0000000000" + x.toString(16)).slice(-r);var s = "04" + A + y;this.setPrivateKeyHex(v);this.setPublicKeyHex(s);return { ecprvhex: v, ecpubhex: s };
+ };this.signWithMessageHash = function (r) {
+ return this.signHex(r, this.prvKeyHex);
+ };this.signHex = function (x, u) {
+ var A = new f(u, 16);var v = this.ecparams.n;var z = new f(x.substring(0, this.ecparams.keylen / 4), 16);do {
+ var w = this.getBigRandom(v);var B = this.ecparams.G;var y = B.multiply(w);var t = y.getX().toBigInteger().mod(v);
+ } while (t.compareTo(f.ZERO) <= 0);var C = w.modInverse(v).multiply(z.add(A.multiply(t))).mod(v);return m.biRSSigToASN1Sig(t, C);
+ };this.sign = function (w, B) {
+ var z = B;var u = this.ecparams.n;var y = f.fromByteArrayUnsigned(w);do {
+ var v = this.getBigRandom(u);var A = this.ecparams.G;var x = A.multiply(v);var t = x.getX().toBigInteger().mod(u);
+ } while (t.compareTo(BigInteger.ZERO) <= 0);var C = v.modInverse(u).multiply(y.add(z.multiply(t))).mod(u);return this.serializeSig(t, C);
+ };this.verifyWithMessageHash = function (s, r) {
+ return this.verifyHex(s, r, this.pubKeyHex);
+ };this.verifyHex = function (v, y, u) {
+ try {
+ var t, B;var w = m.parseSigHex(y);t = w.r;B = w.s;var x = h.decodeFromHex(this.ecparams.curve, u);var z = new f(v.substring(0, this.ecparams.keylen / 4), 16);return this.verifyRaw(z, t, B, x);
+ } catch (A) {
+ return false;
+ }
+ };this.verify = function (z, A, u) {
+ var w, t;if (Bitcoin.Util.isArray(A)) {
+ var y = this.parseSig(A);w = y.r;t = y.s;
+ } else {
+ if ("object" === (typeof A === "undefined" ? "undefined" : _typeof(A)) && A.r && A.s) {
+ w = A.r;t = A.s;
+ } else {
+ throw "Invalid value for signature";
+ }
+ }var v;if (u instanceof ECPointFp) {
+ v = u;
+ } else {
+ if (Bitcoin.Util.isArray(u)) {
+ v = h.decodeFrom(this.ecparams.curve, u);
+ } else {
+ throw "Invalid format for pubkey value, must be byte array or ECPointFp";
+ }
+ }var x = f.fromByteArrayUnsigned(z);return this.verifyRaw(x, w, t, v);
+ };this.verifyRaw = function (z, t, E, y) {
+ var x = this.ecparams.n;var D = this.ecparams.G;if (t.compareTo(f.ONE) < 0 || t.compareTo(x) >= 0) {
+ return false;
+ }if (E.compareTo(f.ONE) < 0 || E.compareTo(x) >= 0) {
+ return false;
+ }var A = E.modInverse(x);var w = z.multiply(A).mod(x);var u = t.multiply(A).mod(x);var B = D.multiply(w).add(y.multiply(u));var C = B.getX().toBigInteger().mod(x);return C.equals(t);
+ };this.serializeSig = function (v, u) {
+ var w = v.toByteArraySigned();var t = u.toByteArraySigned();var x = [];x.push(2);x.push(w.length);x = x.concat(w);x.push(2);x.push(t.length);x = x.concat(t);x.unshift(x.length);x.unshift(48);return x;
+ };this.parseSig = function (y) {
+ var x;if (y[0] != 48) {
+ throw new Error("Signature not a valid DERSequence");
+ }x = 2;if (y[x] != 2) {
+ throw new Error("First element in signature must be a DERInteger");
+ }var w = y.slice(x + 2, x + 2 + y[x + 1]);x += 2 + y[x + 1];if (y[x] != 2) {
+ throw new Error("Second element in signature must be a DERInteger");
+ }var t = y.slice(x + 2, x + 2 + y[x + 1]);x += 2 + y[x + 1];var v = f.fromByteArrayUnsigned(w);var u = f.fromByteArrayUnsigned(t);return { r: v, s: u };
+ };this.parseSigCompact = function (w) {
+ if (w.length !== 65) {
+ throw "Signature has the wrong length";
+ }var t = w[0] - 27;if (t < 0 || t > 7) {
+ throw "Invalid signature type";
+ }var x = this.ecparams.n;var v = f.fromByteArrayUnsigned(w.slice(1, 33)).mod(x);var u = f.fromByteArrayUnsigned(w.slice(33, 65)).mod(x);return { r: v, s: u, i: t };
+ };this.readPKCS5PrvKeyHex = function (u) {
+ if (k(u) === false) {
+ throw new Error("not ASN.1 hex string");
+ }var r, t, v;try {
+ r = n(u, 0, ["[0]", 0], "06");t = n(u, 0, [1], "04");try {
+ v = n(u, 0, ["[1]", 0], "03");
+ } catch (s) {}
+ } catch (s) {
+ throw new Error("malformed PKCS#1/5 plain ECC private key");
+ }this.curveName = d(r);if (this.curveName === undefined) {
+ throw "unsupported curve name";
+ }this.setNamedCurve(this.curveName);this.setPublicKeyHex(v);this.setPrivateKeyHex(t);this.isPublic = false;
+ };this.readPKCS8PrvKeyHex = function (v) {
+ if (k(v) === false) {
+ throw new j("not ASN.1 hex string");
+ }var t, r, u, w;try {
+ t = n(v, 0, [1, 0], "06");r = n(v, 0, [1, 1], "06");u = n(v, 0, [2, 0, 1], "04");try {
+ w = n(v, 0, [2, 0, "[1]", 0], "03");
+ } catch (s) {}
+ } catch (s) {
+ throw new j("malformed PKCS#8 plain ECC private key");
+ }this.curveName = d(r);if (this.curveName === undefined) {
+ throw new j("unsupported curve name");
+ }this.setNamedCurve(this.curveName);this.setPublicKeyHex(w);this.setPrivateKeyHex(u);this.isPublic = false;
+ };this.readPKCS8PubKeyHex = function (u) {
+ if (k(u) === false) {
+ throw new j("not ASN.1 hex string");
+ }var t, r, v;try {
+ t = n(u, 0, [0, 0], "06");r = n(u, 0, [0, 1], "06");v = n(u, 0, [1], "03");
+ } catch (s) {
+ throw new j("malformed PKCS#8 ECC public key");
+ }this.curveName = d(r);if (this.curveName === null) {
+ throw new j("unsupported curve name");
+ }this.setNamedCurve(this.curveName);this.setPublicKeyHex(v);
+ };this.readCertPubKeyHex = function (t, v) {
+ if (k(t) === false) {
+ throw new j("not ASN.1 hex string");
+ }var r, u;try {
+ r = n(t, 0, [0, 5, 0, 1], "06");u = n(t, 0, [0, 5, 1], "03");
+ } catch (s) {
+ throw new j("malformed X.509 certificate ECC public key");
+ }this.curveName = d(r);if (this.curveName === null) {
+ throw new j("unsupported curve name");
+ }this.setNamedCurve(this.curveName);this.setPublicKeyHex(u);
+ };if (e !== undefined) {
+ if (e.curve !== undefined) {
+ this.curveName = e.curve;
+ }
+ }if (this.curveName === undefined) {
+ this.curveName = g;
+ }this.setNamedCurve(this.curveName);if (e !== undefined) {
+ if (e.prv !== undefined) {
+ this.setPrivateKeyHex(e.prv);
+ }if (e.pub !== undefined) {
+ this.setPublicKeyHex(e.pub);
+ }
+ }
+};KJUR.crypto.ECDSA.parseSigHex = function (a) {
+ var b = KJUR.crypto.ECDSA.parseSigHexInHexRS(a);var d = new BigInteger(b.r, 16);var c = new BigInteger(b.s, 16);return { r: d, s: c };
+};KJUR.crypto.ECDSA.parseSigHexInHexRS = function (f) {
+ var j = ASN1HEX,
+ i = j.getChildIdx,
+ g = j.getV;j.checkStrictDER(f, 0);if (f.substr(0, 2) != "30") {
+ throw new Error("signature is not a ASN.1 sequence");
+ }var h = i(f, 0);if (h.length != 2) {
+ throw new Error("signature shall have two elements");
+ }var e = h[0];var d = h[1];if (f.substr(e, 2) != "02") {
+ throw new Error("1st item not ASN.1 integer");
+ }if (f.substr(d, 2) != "02") {
+ throw new Error("2nd item not ASN.1 integer");
+ }var c = g(f, e);var b = g(f, d);return { r: c, s: b };
+};KJUR.crypto.ECDSA.asn1SigToConcatSig = function (c) {
+ var d = KJUR.crypto.ECDSA.parseSigHexInHexRS(c);var b = d.r;var a = d.s;if (b.substr(0, 2) == "00" && b.length % 32 == 2) {
+ b = b.substr(2);
+ }if (a.substr(0, 2) == "00" && a.length % 32 == 2) {
+ a = a.substr(2);
+ }if (b.length % 32 == 30) {
+ b = "00" + b;
+ }if (a.length % 32 == 30) {
+ a = "00" + a;
+ }if (b.length % 32 != 0) {
+ throw "unknown ECDSA sig r length error";
+ }if (a.length % 32 != 0) {
+ throw "unknown ECDSA sig s length error";
+ }return b + a;
+};KJUR.crypto.ECDSA.concatSigToASN1Sig = function (a) {
+ if (a.length / 2 * 8 % (16 * 8) != 0) {
+ throw "unknown ECDSA concatinated r-s sig length error";
+ }var c = a.substr(0, a.length / 2);var b = a.substr(a.length / 2);return KJUR.crypto.ECDSA.hexRSSigToASN1Sig(c, b);
+};KJUR.crypto.ECDSA.hexRSSigToASN1Sig = function (b, a) {
+ var d = new BigInteger(b, 16);var c = new BigInteger(a, 16);return KJUR.crypto.ECDSA.biRSSigToASN1Sig(d, c);
+};KJUR.crypto.ECDSA.biRSSigToASN1Sig = function (f, d) {
+ var c = KJUR.asn1;var b = new c.DERInteger({ bigint: f });var a = new c.DERInteger({ bigint: d });var e = new c.DERSequence({ array: [b, a] });return e.getEncodedHex();
+};KJUR.crypto.ECDSA.getName = function (a) {
+ if (a === "2b8104001f") {
+ return "secp192k1";
+ }if (a === "2a8648ce3d030107") {
+ return "secp256r1";
+ }if (a === "2b8104000a") {
+ return "secp256k1";
+ }if (a === "2b81040021") {
+ return "secp224r1";
+ }if (a === "2b81040022") {
+ return "secp384r1";
+ }if ("|secp256r1|NIST P-256|P-256|prime256v1|".indexOf(a) !== -1) {
+ return "secp256r1";
+ }if ("|secp256k1|".indexOf(a) !== -1) {
+ return "secp256k1";
+ }if ("|secp224r1|NIST P-224|P-224|".indexOf(a) !== -1) {
+ return "secp224r1";
+ }if ("|secp384r1|NIST P-384|P-384|".indexOf(a) !== -1) {
+ return "secp384r1";
+ }return null;
+};
+if (typeof KJUR == "undefined" || !KJUR) {
+ exports.KJUR = KJUR = {};
+}if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}KJUR.crypto.ECParameterDB = new function () {
+ var b = {};var c = {};function a(d) {
+ return new BigInteger(d, 16);
+ }this.getByName = function (e) {
+ var d = e;if (typeof c[d] != "undefined") {
+ d = c[e];
+ }if (typeof b[d] != "undefined") {
+ return b[d];
+ }throw "unregistered EC curve name: " + d;
+ };this.regist = function (A, l, o, g, m, e, j, f, k, u, d, x) {
+ b[A] = {};var s = a(o);var z = a(g);var y = a(m);var t = a(e);var w = a(j);var r = new ECCurveFp(s, z, y);var q = r.decodePointHex("04" + f + k);b[A]["name"] = A;b[A]["keylen"] = l;b[A]["curve"] = r;b[A]["G"] = q;b[A]["n"] = t;b[A]["h"] = w;b[A]["oid"] = d;b[A]["info"] = x;for (var v = 0; v < u.length; v++) {
+ c[u[v]] = A;
+ }
+ };
+}();KJUR.crypto.ECParameterDB.regist("secp128r1", 128, "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC", "E87579C11079F43DD824993C2CEE5ED3", "FFFFFFFE0000000075A30D1B9038A115", "1", "161FF7528B899B2D0C28607CA52C5B86", "CF5AC8395BAFEB13C02DA292DDED7A83", [], "", "secp128r1 : SECG curve over a 128 bit prime field");KJUR.crypto.ECParameterDB.regist("secp160k1", 160, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73", "0", "7", "0100000000000000000001B8FA16DFAB9ACA16B6B3", "1", "3B4C382CE37AA192A4019E763036F4F5DD4D7EBB", "938CF935318FDCED6BC28286531733C3F03C4FEE", [], "", "secp160k1 : SECG curve over a 160 bit prime field");KJUR.crypto.ECParameterDB.regist("secp160r1", 160, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC", "1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45", "0100000000000000000001F4C8F927AED3CA752257", "1", "4A96B5688EF573284664698968C38BB913CBFC82", "23A628553168947D59DCC912042351377AC5FB32", [], "", "secp160r1 : SECG curve over a 160 bit prime field");KJUR.crypto.ECParameterDB.regist("secp192k1", 192, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37", "0", "3", "FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D", "1", "DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D", "9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D", []);KJUR.crypto.ECParameterDB.regist("secp192r1", 192, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC", "64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1", "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831", "1", "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012", "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811", []);KJUR.crypto.ECParameterDB.regist("secp224r1", 224, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE", "B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4", "FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D", "1", "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21", "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34", []);KJUR.crypto.ECParameterDB.regist("secp256k1", 256, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", "0", "7", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", "1", "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", []);KJUR.crypto.ECParameterDB.regist("secp256r1", 256, "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC", "5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B", "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551", "1", "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296", "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5", ["NIST P-256", "P-256", "prime256v1"]);KJUR.crypto.ECParameterDB.regist("secp384r1", 384, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC", "B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973", "1", "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7", "3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f", ["NIST P-384", "P-384"]);KJUR.crypto.ECParameterDB.regist("secp521r1", 521, "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC", "051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409", "1", "C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66", "011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", ["NIST P-521", "P-521"]);
+var KEYUTIL = function () {
+ var d = function d(p, r, q) {
+ return k(CryptoJS.AES, p, r, q);
+ };var e = function e(p, r, q) {
+ return k(CryptoJS.TripleDES, p, r, q);
+ };var a = function a(p, r, q) {
+ return k(CryptoJS.DES, p, r, q);
+ };var k = function k(s, x, u, q) {
+ var r = CryptoJS.enc.Hex.parse(x);var w = CryptoJS.enc.Hex.parse(u);var p = CryptoJS.enc.Hex.parse(q);var t = {};t.key = w;t.iv = p;t.ciphertext = r;var v = s.decrypt(t, w, { iv: p });return CryptoJS.enc.Hex.stringify(v);
+ };var l = function l(p, r, q) {
+ return g(CryptoJS.AES, p, r, q);
+ };var o = function o(p, r, q) {
+ return g(CryptoJS.TripleDES, p, r, q);
+ };var f = function f(p, r, q) {
+ return g(CryptoJS.DES, p, r, q);
+ };var g = function g(t, y, v, q) {
+ var s = CryptoJS.enc.Hex.parse(y);var x = CryptoJS.enc.Hex.parse(v);var p = CryptoJS.enc.Hex.parse(q);var w = t.encrypt(s, x, { iv: p });var r = CryptoJS.enc.Hex.parse(w.toString());var u = CryptoJS.enc.Base64.stringify(r);return u;
+ };var i = { "AES-256-CBC": { proc: d, eproc: l, keylen: 32, ivlen: 16 }, "AES-192-CBC": { proc: d, eproc: l, keylen: 24, ivlen: 16 }, "AES-128-CBC": { proc: d, eproc: l, keylen: 16, ivlen: 16 }, "DES-EDE3-CBC": { proc: e, eproc: o, keylen: 24, ivlen: 8 }, "DES-CBC": { proc: a, eproc: f, keylen: 8, ivlen: 8 } };var c = function c(p) {
+ return i[p]["proc"];
+ };var m = function m(p) {
+ var r = CryptoJS.lib.WordArray.random(p);var q = CryptoJS.enc.Hex.stringify(r);return q;
+ };var n = function n(v) {
+ var w = {};var q = v.match(new RegExp("DEK-Info: ([^,]+),([0-9A-Fa-f]+)", "m"));if (q) {
+ w.cipher = q[1];w.ivsalt = q[2];
+ }var p = v.match(new RegExp("-----BEGIN ([A-Z]+) PRIVATE KEY-----"));if (p) {
+ w.type = p[1];
+ }var u = -1;var x = 0;if (v.indexOf("\r\n\r\n") != -1) {
+ u = v.indexOf("\r\n\r\n");x = 2;
+ }if (v.indexOf("\n\n") != -1) {
+ u = v.indexOf("\n\n");x = 1;
+ }var t = v.indexOf("-----END");if (u != -1 && t != -1) {
+ var r = v.substring(u + x * 2, t - x);r = r.replace(/\s+/g, "");w.data = r;
+ }return w;
+ };var j = function j(q, y, p) {
+ var v = p.substring(0, 16);var t = CryptoJS.enc.Hex.parse(v);var r = CryptoJS.enc.Utf8.parse(y);var u = i[q]["keylen"] + i[q]["ivlen"];var x = "";var w = null;for (;;) {
+ var s = CryptoJS.algo.MD5.create();if (w != null) {
+ s.update(w);
+ }s.update(r);s.update(t);w = s.finalize();x = x + CryptoJS.enc.Hex.stringify(w);if (x.length >= u * 2) {
+ break;
+ }
+ }var z = {};z.keyhex = x.substr(0, i[q]["keylen"] * 2);z.ivhex = x.substr(i[q]["keylen"] * 2, i[q]["ivlen"] * 2);return z;
+ };var b = function b(p, v, r, w) {
+ var s = CryptoJS.enc.Base64.parse(p);var q = CryptoJS.enc.Hex.stringify(s);var u = i[v]["proc"];var t = u(q, r, w);return t;
+ };var h = function h(p, s, q, u) {
+ var r = i[s]["eproc"];var t = r(p, q, u);return t;
+ };return { version: "1.0.0", parsePKCS5PEM: function parsePKCS5PEM(p) {
+ return n(p);
+ }, getKeyAndUnusedIvByPasscodeAndIvsalt: function getKeyAndUnusedIvByPasscodeAndIvsalt(q, p, r) {
+ return j(q, p, r);
+ }, decryptKeyB64: function decryptKeyB64(p, r, q, s) {
+ return b(p, r, q, s);
+ }, getDecryptedKeyHex: function getDecryptedKeyHex(y, x) {
+ var q = n(y);var t = q.type;var r = q.cipher;var p = q.ivsalt;var s = q.data;var w = j(r, x, p);var v = w.keyhex;var u = b(s, r, v, p);return u;
+ }, getEncryptedPKCS5PEMFromPrvKeyHex: function getEncryptedPKCS5PEMFromPrvKeyHex(x, s, A, t, r) {
+ var p = "";if (typeof t == "undefined" || t == null) {
+ t = "AES-256-CBC";
+ }if (typeof i[t] == "undefined") {
+ throw new Error("KEYUTIL unsupported algorithm: " + t);
+ }if (typeof r == "undefined" || r == null) {
+ var v = i[t]["ivlen"];var u = m(v);r = u.toUpperCase();
+ }var z = j(t, A, r);var y = z.keyhex;var w = h(s, t, y, r);var q = w.replace(/(.{64})/g, "$1\r\n");var p = "-----BEGIN " + x + " PRIVATE KEY-----\r\n";p += "Proc-Type: 4,ENCRYPTED\r\n";p += "DEK-Info: " + t + "," + r + "\r\n";p += "\r\n";p += q;p += "\r\n-----END " + x + " PRIVATE KEY-----\r\n";return p;
+ }, parseHexOfEncryptedPKCS8: function parseHexOfEncryptedPKCS8(y) {
+ var B = ASN1HEX;var z = B.getChildIdx;var w = B.getV;var t = {};var r = z(y, 0);if (r.length != 2) {
+ throw new Error("malformed format: SEQUENCE(0).items != 2: " + r.length);
+ }t.ciphertext = w(y, r[1]);var A = z(y, r[0]);if (A.length != 2) {
+ throw new Error("malformed format: SEQUENCE(0.0).items != 2: " + A.length);
+ }if (w(y, A[0]) != "2a864886f70d01050d") {
+ throw new Error("this only supports pkcs5PBES2");
+ }var p = z(y, A[1]);if (A.length != 2) {
+ throw new Error("malformed format: SEQUENCE(0.0.1).items != 2: " + p.length);
+ }var q = z(y, p[1]);if (q.length != 2) {
+ throw new Error("malformed format: SEQUENCE(0.0.1.1).items != 2: " + q.length);
+ }if (w(y, q[0]) != "2a864886f70d0307") {
+ throw "this only supports TripleDES";
+ }t.encryptionSchemeAlg = "TripleDES";t.encryptionSchemeIV = w(y, q[1]);var s = z(y, p[0]);if (s.length != 2) {
+ throw new Error("malformed format: SEQUENCE(0.0.1.0).items != 2: " + s.length);
+ }if (w(y, s[0]) != "2a864886f70d01050c") {
+ throw new Error("this only supports pkcs5PBKDF2");
+ }var x = z(y, s[1]);if (x.length < 2) {
+ throw new Error("malformed format: SEQUENCE(0.0.1.0.1).items < 2: " + x.length);
+ }t.pbkdf2Salt = w(y, x[0]);var u = w(y, x[1]);try {
+ t.pbkdf2Iter = parseInt(u, 16);
+ } catch (v) {
+ throw new Error("malformed format pbkdf2Iter: " + u);
+ }return t;
+ }, getPBKDF2KeyHexFromParam: function getPBKDF2KeyHexFromParam(u, p) {
+ var t = CryptoJS.enc.Hex.parse(u.pbkdf2Salt);var q = u.pbkdf2Iter;var s = CryptoJS.PBKDF2(p, t, { keySize: 192 / 32, iterations: q });var r = CryptoJS.enc.Hex.stringify(s);return r;
+ }, _getPlainPKCS8HexFromEncryptedPKCS8PEM: function _getPlainPKCS8HexFromEncryptedPKCS8PEM(x, y) {
+ var r = pemtohex(x, "ENCRYPTED PRIVATE KEY");var p = this.parseHexOfEncryptedPKCS8(r);var u = KEYUTIL.getPBKDF2KeyHexFromParam(p, y);var v = {};v.ciphertext = CryptoJS.enc.Hex.parse(p.ciphertext);var t = CryptoJS.enc.Hex.parse(u);var s = CryptoJS.enc.Hex.parse(p.encryptionSchemeIV);var w = CryptoJS.TripleDES.decrypt(v, t, { iv: s });var q = CryptoJS.enc.Hex.stringify(w);return q;
+ }, getKeyFromEncryptedPKCS8PEM: function getKeyFromEncryptedPKCS8PEM(s, q) {
+ var p = this._getPlainPKCS8HexFromEncryptedPKCS8PEM(s, q);var r = this.getKeyFromPlainPrivatePKCS8Hex(p);return r;
+ }, parsePlainPrivatePKCS8Hex: function parsePlainPrivatePKCS8Hex(s) {
+ var v = ASN1HEX;var u = v.getChildIdx;var t = v.getV;var q = {};q.algparam = null;if (s.substr(0, 2) != "30") {
+ throw new Error("malformed plain PKCS8 private key(code:001)");
+ }var r = u(s, 0);if (r.length < 3) {
+ throw new Error("malformed plain PKCS8 private key(code:002)");
+ }if (s.substr(r[1], 2) != "30") {
+ throw new Error("malformed PKCS8 private key(code:003)");
+ }var p = u(s, r[1]);if (p.length != 2) {
+ throw new Error("malformed PKCS8 private key(code:004)");
+ }if (s.substr(p[0], 2) != "06") {
+ throw new Error("malformed PKCS8 private key(code:005)");
+ }q.algoid = t(s, p[0]);if (s.substr(p[1], 2) == "06") {
+ q.algparam = t(s, p[1]);
+ }if (s.substr(r[2], 2) != "04") {
+ throw new Error("malformed PKCS8 private key(code:006)");
+ }q.keyidx = v.getVidx(s, r[2]);return q;
+ }, getKeyFromPlainPrivatePKCS8PEM: function getKeyFromPlainPrivatePKCS8PEM(q) {
+ var p = pemtohex(q, "PRIVATE KEY");var r = this.getKeyFromPlainPrivatePKCS8Hex(p);return r;
+ }, getKeyFromPlainPrivatePKCS8Hex: function getKeyFromPlainPrivatePKCS8Hex(p) {
+ var q = this.parsePlainPrivatePKCS8Hex(p);var r;if (q.algoid == "2a864886f70d010101") {
+ r = new RSAKey();
+ } else {
+ if (q.algoid == "2a8648ce380401") {
+ r = new KJUR.crypto.DSA();
+ } else {
+ if (q.algoid == "2a8648ce3d0201") {
+ r = new KJUR.crypto.ECDSA();
+ } else {
+ throw new Error("unsupported private key algorithm");
+ }
+ }
+ }r.readPKCS8PrvKeyHex(p);return r;
+ }, _getKeyFromPublicPKCS8Hex: function _getKeyFromPublicPKCS8Hex(q) {
+ var p;var r = ASN1HEX.getVbyList(q, 0, [0, 0], "06");if (r === "2a864886f70d010101") {
+ p = new RSAKey();
+ } else {
+ if (r === "2a8648ce380401") {
+ p = new KJUR.crypto.DSA();
+ } else {
+ if (r === "2a8648ce3d0201") {
+ p = new KJUR.crypto.ECDSA();
+ } else {
+ throw new Error("unsupported PKCS#8 public key hex");
+ }
+ }
+ }p.readPKCS8PubKeyHex(q);return p;
+ }, parsePublicRawRSAKeyHex: function parsePublicRawRSAKeyHex(r) {
+ var u = ASN1HEX;var t = u.getChildIdx;var s = u.getV;var p = {};if (r.substr(0, 2) != "30") {
+ throw new Error("malformed RSA key(code:001)");
+ }var q = t(r, 0);if (q.length != 2) {
+ throw new Error("malformed RSA key(code:002)");
+ }if (r.substr(q[0], 2) != "02") {
+ throw new Error("malformed RSA key(code:003)");
+ }p.n = s(r, q[0]);if (r.substr(q[1], 2) != "02") {
+ throw new Error("malformed RSA key(code:004)");
+ }p.e = s(r, q[1]);return p;
+ }, parsePublicPKCS8Hex: function parsePublicPKCS8Hex(t) {
+ var v = ASN1HEX;var u = v.getChildIdx;var s = v.getV;var q = {};q.algparam = null;var r = u(t, 0);if (r.length != 2) {
+ throw new Error("outer DERSequence shall have 2 elements: " + r.length);
+ }var w = r[0];if (t.substr(w, 2) != "30") {
+ throw new Error("malformed PKCS8 public key(code:001)");
+ }var p = u(t, w);if (p.length != 2) {
+ throw new Error("malformed PKCS8 public key(code:002)");
+ }if (t.substr(p[0], 2) != "06") {
+ throw new Error("malformed PKCS8 public key(code:003)");
+ }q.algoid = s(t, p[0]);if (t.substr(p[1], 2) == "06") {
+ q.algparam = s(t, p[1]);
+ } else {
+ if (t.substr(p[1], 2) == "30") {
+ q.algparam = {};q.algparam.p = v.getVbyList(t, p[1], [0], "02");q.algparam.q = v.getVbyList(t, p[1], [1], "02");q.algparam.g = v.getVbyList(t, p[1], [2], "02");
+ }
+ }if (t.substr(r[1], 2) != "03") {
+ throw new Error("malformed PKCS8 public key(code:004)");
+ }q.key = s(t, r[1]).substr(2);return q;
+ } };
+}();KEYUTIL.getKey = function (l, k, n) {
+ var G = ASN1HEX,
+ L = G.getChildIdx,
+ v = G.getV,
+ d = G.getVbyList,
+ c = KJUR.crypto,
+ i = c.ECDSA,
+ C = c.DSA,
+ w = RSAKey,
+ M = pemtohex,
+ F = KEYUTIL;if (typeof w != "undefined" && l instanceof w) {
+ return l;
+ }if (typeof i != "undefined" && l instanceof i) {
+ return l;
+ }if (typeof C != "undefined" && l instanceof C) {
+ return l;
+ }if (l.curve !== undefined && l.xy !== undefined && l.d === undefined) {
+ return new i({ pub: l.xy, curve: l.curve });
+ }if (l.curve !== undefined && l.d !== undefined) {
+ return new i({ prv: l.d, curve: l.curve });
+ }if (l.kty === undefined && l.n !== undefined && l.e !== undefined && l.d === undefined) {
+ var P = new w();P.setPublic(l.n, l.e);return P;
+ }if (l.kty === undefined && l.n !== undefined && l.e !== undefined && l.d !== undefined && l.p !== undefined && l.q !== undefined && l.dp !== undefined && l.dq !== undefined && l.co !== undefined && l.qi === undefined) {
+ var P = new w();P.setPrivateEx(l.n, l.e, l.d, l.p, l.q, l.dp, l.dq, l.co);return P;
+ }if (l.kty === undefined && l.n !== undefined && l.e !== undefined && l.d !== undefined && l.p === undefined) {
+ var P = new w();P.setPrivate(l.n, l.e, l.d);return P;
+ }if (l.p !== undefined && l.q !== undefined && l.g !== undefined && l.y !== undefined && l.x === undefined) {
+ var P = new C();P.setPublic(l.p, l.q, l.g, l.y);return P;
+ }if (l.p !== undefined && l.q !== undefined && l.g !== undefined && l.y !== undefined && l.x !== undefined) {
+ var P = new C();P.setPrivate(l.p, l.q, l.g, l.y, l.x);return P;
+ }if (l.kty === "RSA" && l.n !== undefined && l.e !== undefined && l.d === undefined) {
+ var P = new w();P.setPublic(b64utohex(l.n), b64utohex(l.e));return P;
+ }if (l.kty === "RSA" && l.n !== undefined && l.e !== undefined && l.d !== undefined && l.p !== undefined && l.q !== undefined && l.dp !== undefined && l.dq !== undefined && l.qi !== undefined) {
+ var P = new w();P.setPrivateEx(b64utohex(l.n), b64utohex(l.e), b64utohex(l.d), b64utohex(l.p), b64utohex(l.q), b64utohex(l.dp), b64utohex(l.dq), b64utohex(l.qi));return P;
+ }if (l.kty === "RSA" && l.n !== undefined && l.e !== undefined && l.d !== undefined) {
+ var P = new w();P.setPrivate(b64utohex(l.n), b64utohex(l.e), b64utohex(l.d));return P;
+ }if (l.kty === "EC" && l.crv !== undefined && l.x !== undefined && l.y !== undefined && l.d === undefined) {
+ var j = new i({ curve: l.crv });var t = j.ecparams.keylen / 4;var B = ("0000000000" + b64utohex(l.x)).slice(-t);var z = ("0000000000" + b64utohex(l.y)).slice(-t);var u = "04" + B + z;j.setPublicKeyHex(u);return j;
+ }if (l.kty === "EC" && l.crv !== undefined && l.x !== undefined && l.y !== undefined && l.d !== undefined) {
+ var j = new i({ curve: l.crv });var t = j.ecparams.keylen / 4;var B = ("0000000000" + b64utohex(l.x)).slice(-t);var z = ("0000000000" + b64utohex(l.y)).slice(-t);var u = "04" + B + z;var b = ("0000000000" + b64utohex(l.d)).slice(-t);j.setPublicKeyHex(u);j.setPrivateKeyHex(b);return j;
+ }if (n === "pkcs5prv") {
+ var J = l,
+ G = ASN1HEX,
+ N,
+ P;N = L(J, 0);if (N.length === 9) {
+ P = new w();P.readPKCS5PrvKeyHex(J);
+ } else {
+ if (N.length === 6) {
+ P = new C();P.readPKCS5PrvKeyHex(J);
+ } else {
+ if (N.length > 2 && J.substr(N[1], 2) === "04") {
+ P = new i();P.readPKCS5PrvKeyHex(J);
+ } else {
+ throw new Error("unsupported PKCS#1/5 hexadecimal key");
+ }
+ }
+ }return P;
+ }if (n === "pkcs8prv") {
+ var P = F.getKeyFromPlainPrivatePKCS8Hex(l);return P;
+ }if (n === "pkcs8pub") {
+ return F._getKeyFromPublicPKCS8Hex(l);
+ }if (n === "x509pub") {
+ return X509.getPublicKeyFromCertHex(l);
+ }if (l.indexOf("-END CERTIFICATE-", 0) != -1 || l.indexOf("-END X509 CERTIFICATE-", 0) != -1 || l.indexOf("-END TRUSTED CERTIFICATE-", 0) != -1) {
+ return X509.getPublicKeyFromCertPEM(l);
+ }if (l.indexOf("-END PUBLIC KEY-") != -1) {
+ var O = pemtohex(l, "PUBLIC KEY");return F._getKeyFromPublicPKCS8Hex(O);
+ }if (l.indexOf("-END RSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") == -1) {
+ var m = M(l, "RSA PRIVATE KEY");return F.getKey(m, null, "pkcs5prv");
+ }if (l.indexOf("-END DSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") == -1) {
+ var I = M(l, "DSA PRIVATE KEY");var E = d(I, 0, [1], "02");var D = d(I, 0, [2], "02");var K = d(I, 0, [3], "02");var r = d(I, 0, [4], "02");var s = d(I, 0, [5], "02");var P = new C();P.setPrivate(new BigInteger(E, 16), new BigInteger(D, 16), new BigInteger(K, 16), new BigInteger(r, 16), new BigInteger(s, 16));return P;
+ }if (l.indexOf("-END EC PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") == -1) {
+ var m = M(l, "EC PRIVATE KEY");return F.getKey(m, null, "pkcs5prv");
+ }if (l.indexOf("-END PRIVATE KEY-") != -1) {
+ return F.getKeyFromPlainPrivatePKCS8PEM(l);
+ }if (l.indexOf("-END RSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") != -1) {
+ var o = F.getDecryptedKeyHex(l, k);var H = new RSAKey();H.readPKCS5PrvKeyHex(o);return H;
+ }if (l.indexOf("-END EC PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") != -1) {
+ var I = F.getDecryptedKeyHex(l, k);var P = d(I, 0, [1], "04");var f = d(I, 0, [2, 0], "06");var A = d(I, 0, [3, 0], "03").substr(2);var e = "";if (KJUR.crypto.OID.oidhex2name[f] !== undefined) {
+ e = KJUR.crypto.OID.oidhex2name[f];
+ } else {
+ throw new Error("undefined OID(hex) in KJUR.crypto.OID: " + f);
+ }var j = new i({ curve: e });j.setPublicKeyHex(A);j.setPrivateKeyHex(P);j.isPublic = false;return j;
+ }if (l.indexOf("-END DSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") != -1) {
+ var I = F.getDecryptedKeyHex(l, k);var E = d(I, 0, [1], "02");var D = d(I, 0, [2], "02");var K = d(I, 0, [3], "02");var r = d(I, 0, [4], "02");var s = d(I, 0, [5], "02");var P = new C();P.setPrivate(new BigInteger(E, 16), new BigInteger(D, 16), new BigInteger(K, 16), new BigInteger(r, 16), new BigInteger(s, 16));return P;
+ }if (l.indexOf("-END ENCRYPTED PRIVATE KEY-") != -1) {
+ return F.getKeyFromEncryptedPKCS8PEM(l, k);
+ }throw new Error("not supported argument");
+};KEYUTIL.generateKeypair = function (a, c) {
+ if (a == "RSA") {
+ var b = c;var h = new RSAKey();h.generate(b, "10001");h.isPrivate = true;h.isPublic = true;var f = new RSAKey();var e = h.n.toString(16);var i = h.e.toString(16);f.setPublic(e, i);f.isPrivate = false;f.isPublic = true;var k = {};k.prvKeyObj = h;k.pubKeyObj = f;return k;
+ } else {
+ if (a == "EC") {
+ var d = c;var g = new KJUR.crypto.ECDSA({ curve: d });var j = g.generateKeyPairHex();var h = new KJUR.crypto.ECDSA({ curve: d });h.setPublicKeyHex(j.ecpubhex);h.setPrivateKeyHex(j.ecprvhex);h.isPrivate = true;h.isPublic = false;var f = new KJUR.crypto.ECDSA({ curve: d });f.setPublicKeyHex(j.ecpubhex);f.isPrivate = false;f.isPublic = true;var k = {};k.prvKeyObj = h;k.pubKeyObj = f;return k;
+ } else {
+ throw new Error("unknown algorithm: " + a);
+ }
+ }
+};KEYUTIL.getPEM = function (b, D, y, m, q, j) {
+ var F = KJUR,
+ k = F.asn1,
+ z = k.DERObjectIdentifier,
+ f = k.DERInteger,
+ l = k.ASN1Util.newObject,
+ a = k.x509,
+ C = a.SubjectPublicKeyInfo,
+ e = F.crypto,
+ u = e.DSA,
+ r = e.ECDSA,
+ n = RSAKey;function A(s) {
+ var G = l({ seq: [{ "int": 0 }, { "int": { bigint: s.n } }, { "int": s.e }, { "int": { bigint: s.d } }, { "int": { bigint: s.p } }, { "int": { bigint: s.q } }, { "int": { bigint: s.dmp1 } }, { "int": { bigint: s.dmq1 } }, { "int": { bigint: s.coeff } }] });return G;
+ }function B(G) {
+ var s = l({ seq: [{ "int": 1 }, { octstr: { hex: G.prvKeyHex } }, { tag: ["a0", true, { oid: { name: G.curveName } }] }, { tag: ["a1", true, { bitstr: { hex: "00" + G.pubKeyHex } }] }] });return s;
+ }function x(s) {
+ var G = l({ seq: [{ "int": 0 }, { "int": { bigint: s.p } }, { "int": { bigint: s.q } }, { "int": { bigint: s.g } }, { "int": { bigint: s.y } }, { "int": { bigint: s.x } }] });return G;
+ }if ((n !== undefined && b instanceof n || u !== undefined && b instanceof u || r !== undefined && b instanceof r) && b.isPublic == true && (D === undefined || D == "PKCS8PUB")) {
+ var E = new C(b);var w = E.getEncodedHex();return hextopem(w, "PUBLIC KEY");
+ }if (D == "PKCS1PRV" && n !== undefined && b instanceof n && (y === undefined || y == null) && b.isPrivate == true) {
+ var E = A(b);var w = E.getEncodedHex();return hextopem(w, "RSA PRIVATE KEY");
+ }if (D == "PKCS1PRV" && r !== undefined && b instanceof r && (y === undefined || y == null) && b.isPrivate == true) {
+ var i = new z({ name: b.curveName });var v = i.getEncodedHex();var h = B(b);var t = h.getEncodedHex();var p = "";p += hextopem(v, "EC PARAMETERS");p += hextopem(t, "EC PRIVATE KEY");return p;
+ }if (D == "PKCS1PRV" && u !== undefined && b instanceof u && (y === undefined || y == null) && b.isPrivate == true) {
+ var E = x(b);var w = E.getEncodedHex();return hextopem(w, "DSA PRIVATE KEY");
+ }if (D == "PKCS5PRV" && n !== undefined && b instanceof n && y !== undefined && y != null && b.isPrivate == true) {
+ var E = A(b);var w = E.getEncodedHex();if (m === undefined) {
+ m = "DES-EDE3-CBC";
+ }return this.getEncryptedPKCS5PEMFromPrvKeyHex("RSA", w, y, m, j);
+ }if (D == "PKCS5PRV" && r !== undefined && b instanceof r && y !== undefined && y != null && b.isPrivate == true) {
+ var E = B(b);var w = E.getEncodedHex();if (m === undefined) {
+ m = "DES-EDE3-CBC";
+ }return this.getEncryptedPKCS5PEMFromPrvKeyHex("EC", w, y, m, j);
+ }if (D == "PKCS5PRV" && u !== undefined && b instanceof u && y !== undefined && y != null && b.isPrivate == true) {
+ var E = x(b);var w = E.getEncodedHex();if (m === undefined) {
+ m = "DES-EDE3-CBC";
+ }return this.getEncryptedPKCS5PEMFromPrvKeyHex("DSA", w, y, m, j);
+ }var o = function o(G, s) {
+ var I = c(G, s);var H = new l({ seq: [{ seq: [{ oid: { name: "pkcs5PBES2" } }, { seq: [{ seq: [{ oid: { name: "pkcs5PBKDF2" } }, { seq: [{ octstr: { hex: I.pbkdf2Salt } }, { "int": I.pbkdf2Iter }] }] }, { seq: [{ oid: { name: "des-EDE3-CBC" } }, { octstr: { hex: I.encryptionSchemeIV } }] }] }] }, { octstr: { hex: I.ciphertext } }] });return H.getEncodedHex();
+ };var c = function c(N, O) {
+ var H = 100;var M = CryptoJS.lib.WordArray.random(8);var L = "DES-EDE3-CBC";var s = CryptoJS.lib.WordArray.random(8);var I = CryptoJS.PBKDF2(O, M, { keySize: 192 / 32, iterations: H });var J = CryptoJS.enc.Hex.parse(N);var K = CryptoJS.TripleDES.encrypt(J, I, { iv: s }) + "";var G = {};G.ciphertext = K;G.pbkdf2Salt = CryptoJS.enc.Hex.stringify(M);G.pbkdf2Iter = H;G.encryptionSchemeAlg = L;G.encryptionSchemeIV = CryptoJS.enc.Hex.stringify(s);return G;
+ };if (D == "PKCS8PRV" && n != undefined && b instanceof n && b.isPrivate == true) {
+ var g = A(b);var d = g.getEncodedHex();var E = l({ seq: [{ "int": 0 }, { seq: [{ oid: { name: "rsaEncryption" } }, { "null": true }] }, { octstr: { hex: d } }] });var w = E.getEncodedHex();if (y === undefined || y == null) {
+ return hextopem(w, "PRIVATE KEY");
+ } else {
+ var t = o(w, y);return hextopem(t, "ENCRYPTED PRIVATE KEY");
+ }
+ }if (D == "PKCS8PRV" && r !== undefined && b instanceof r && b.isPrivate == true) {
+ var g = new l({ seq: [{ "int": 1 }, { octstr: { hex: b.prvKeyHex } }, { tag: ["a1", true, { bitstr: { hex: "00" + b.pubKeyHex } }] }] });var d = g.getEncodedHex();var E = l({ seq: [{ "int": 0 }, { seq: [{ oid: { name: "ecPublicKey" } }, { oid: { name: b.curveName } }] }, { octstr: { hex: d } }] });var w = E.getEncodedHex();if (y === undefined || y == null) {
+ return hextopem(w, "PRIVATE KEY");
+ } else {
+ var t = o(w, y);return hextopem(t, "ENCRYPTED PRIVATE KEY");
+ }
+ }if (D == "PKCS8PRV" && u !== undefined && b instanceof u && b.isPrivate == true) {
+ var g = new f({ bigint: b.x });var d = g.getEncodedHex();var E = l({ seq: [{ "int": 0 }, { seq: [{ oid: { name: "dsa" } }, { seq: [{ "int": { bigint: b.p } }, { "int": { bigint: b.q } }, { "int": { bigint: b.g } }] }] }, { octstr: { hex: d } }] });var w = E.getEncodedHex();if (y === undefined || y == null) {
+ return hextopem(w, "PRIVATE KEY");
+ } else {
+ var t = o(w, y);return hextopem(t, "ENCRYPTED PRIVATE KEY");
+ }
+ }throw new Error("unsupported object nor format");
+};KEYUTIL.getKeyFromCSRPEM = function (b) {
+ var a = pemtohex(b, "CERTIFICATE REQUEST");var c = KEYUTIL.getKeyFromCSRHex(a);return c;
+};KEYUTIL.getKeyFromCSRHex = function (a) {
+ var c = KEYUTIL.parseCSRHex(a);var b = KEYUTIL.getKey(c.p8pubkeyhex, null, "pkcs8pub");return b;
+};KEYUTIL.parseCSRHex = function (d) {
+ var i = ASN1HEX;var f = i.getChildIdx;var c = i.getTLV;var b = {};var g = d;if (g.substr(0, 2) != "30") {
+ throw new Error("malformed CSR(code:001)");
+ }var e = f(g, 0);if (e.length < 1) {
+ throw new Error("malformed CSR(code:002)");
+ }if (g.substr(e[0], 2) != "30") {
+ throw new Error("malformed CSR(code:003)");
+ }var a = f(g, e[0]);if (a.length < 3) {
+ throw new Error("malformed CSR(code:004)");
+ }b.p8pubkeyhex = c(g, a[2]);return b;
+};KEYUTIL.getKeyID = function (f) {
+ var c = KEYUTIL;var e = ASN1HEX;if (typeof f === "string" && f.indexOf("BEGIN ") != -1) {
+ f = c.getKey(f);
+ }var d = pemtohex(c.getPEM(f));var b = e.getIdxbyList(d, 0, [1]);var a = e.getV(d, b).substring(2);return KJUR.crypto.Util.hashHex(a, "sha1");
+};KEYUTIL.getJWKFromKey = function (d) {
+ var b = {};if (d instanceof RSAKey && d.isPrivate) {
+ b.kty = "RSA";b.n = hextob64u(d.n.toString(16));b.e = hextob64u(d.e.toString(16));b.d = hextob64u(d.d.toString(16));b.p = hextob64u(d.p.toString(16));b.q = hextob64u(d.q.toString(16));b.dp = hextob64u(d.dmp1.toString(16));b.dq = hextob64u(d.dmq1.toString(16));b.qi = hextob64u(d.coeff.toString(16));return b;
+ } else {
+ if (d instanceof RSAKey && d.isPublic) {
+ b.kty = "RSA";b.n = hextob64u(d.n.toString(16));b.e = hextob64u(d.e.toString(16));return b;
+ } else {
+ if (d instanceof KJUR.crypto.ECDSA && d.isPrivate) {
+ var a = d.getShortNISTPCurveName();if (a !== "P-256" && a !== "P-384") {
+ throw new Error("unsupported curve name for JWT: " + a);
+ }var c = d.getPublicKeyXYHex();b.kty = "EC";b.crv = a;b.x = hextob64u(c.x);b.y = hextob64u(c.y);b.d = hextob64u(d.prvKeyHex);return b;
+ } else {
+ if (d instanceof KJUR.crypto.ECDSA && d.isPublic) {
+ var a = d.getShortNISTPCurveName();if (a !== "P-256" && a !== "P-384") {
+ throw new Error("unsupported curve name for JWT: " + a);
+ }var c = d.getPublicKeyXYHex();b.kty = "EC";b.crv = a;b.x = hextob64u(c.x);b.y = hextob64u(c.y);return b;
+ }
+ }
+ }
+ }throw new Error("not supported key object");
+};
+RSAKey.getPosArrayOfChildrenFromHex = function (a) {
+ return ASN1HEX.getChildIdx(a, 0);
+};RSAKey.getHexValueArrayOfChildrenFromHex = function (f) {
+ var n = ASN1HEX;var i = n.getV;var k = RSAKey.getPosArrayOfChildrenFromHex(f);var e = i(f, k[0]);var j = i(f, k[1]);var b = i(f, k[2]);var c = i(f, k[3]);var h = i(f, k[4]);var g = i(f, k[5]);var m = i(f, k[6]);var l = i(f, k[7]);var d = i(f, k[8]);var k = new Array();k.push(e, j, b, c, h, g, m, l, d);return k;
+};RSAKey.prototype.readPrivateKeyFromPEMString = function (d) {
+ var c = pemtohex(d);var b = RSAKey.getHexValueArrayOfChildrenFromHex(c);this.setPrivateEx(b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8]);
+};RSAKey.prototype.readPKCS5PrvKeyHex = function (c) {
+ var b = RSAKey.getHexValueArrayOfChildrenFromHex(c);this.setPrivateEx(b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8]);
+};RSAKey.prototype.readPKCS8PrvKeyHex = function (e) {
+ var c, i, k, b, a, f, d, j;var m = ASN1HEX;var l = m.getVbyListEx;if (m.isASN1HEX(e) === false) {
+ throw new Error("not ASN.1 hex string");
+ }try {
+ c = l(e, 0, [2, 0, 1], "02");i = l(e, 0, [2, 0, 2], "02");k = l(e, 0, [2, 0, 3], "02");b = l(e, 0, [2, 0, 4], "02");a = l(e, 0, [2, 0, 5], "02");f = l(e, 0, [2, 0, 6], "02");d = l(e, 0, [2, 0, 7], "02");j = l(e, 0, [2, 0, 8], "02");
+ } catch (g) {
+ throw new Error("malformed PKCS#8 plain RSA private key");
+ }this.setPrivateEx(c, i, k, b, a, f, d, j);
+};RSAKey.prototype.readPKCS5PubKeyHex = function (c) {
+ var e = ASN1HEX;var b = e.getV;if (e.isASN1HEX(c) === false) {
+ throw new Error("keyHex is not ASN.1 hex string");
+ }var a = e.getChildIdx(c, 0);if (a.length !== 2 || c.substr(a[0], 2) !== "02" || c.substr(a[1], 2) !== "02") {
+ throw new Error("wrong hex for PKCS#5 public key");
+ }var f = b(c, a[0]);var d = b(c, a[1]);this.setPublic(f, d);
+};RSAKey.prototype.readPKCS8PubKeyHex = function (b) {
+ var c = ASN1HEX;if (c.isASN1HEX(b) === false) {
+ throw new Error("not ASN.1 hex string");
+ }if (c.getTLVbyListEx(b, 0, [0, 0]) !== "06092a864886f70d010101") {
+ throw new Error("not PKCS8 RSA public key");
+ }var a = c.getTLVbyListEx(b, 0, [1, 0]);this.readPKCS5PubKeyHex(a);
+};RSAKey.prototype.readCertPubKeyHex = function (b, d) {
+ var a, c;a = new X509();a.readCertHex(b);c = a.getPublicKeyHex();this.readPKCS8PubKeyHex(c);
+};
+var _RE_HEXDECONLY = new RegExp("[^0-9a-f]", "gi");function _rsasign_getHexPaddedDigestInfoForString(d, e, a) {
+ var b = function b(f) {
+ return KJUR.crypto.Util.hashString(f, a);
+ };var c = b(d);return KJUR.crypto.Util.getPaddedDigestInfoHex(c, a, e);
+}function _zeroPaddingOfSignature(e, d) {
+ var c = "";var a = d / 4 - e.length;for (var b = 0; b < a; b++) {
+ c = c + "0";
+ }return c + e;
+}RSAKey.prototype.sign = function (d, a) {
+ var b = function b(e) {
+ return KJUR.crypto.Util.hashString(e, a);
+ };var c = b(d);return this.signWithMessageHash(c, a);
+};RSAKey.prototype.signWithMessageHash = function (e, c) {
+ var f = KJUR.crypto.Util.getPaddedDigestInfoHex(e, c, this.n.bitLength());var b = parseBigInt(f, 16);var d = this.doPrivate(b);var a = d.toString(16);return _zeroPaddingOfSignature(a, this.n.bitLength());
+};function pss_mgf1_str(c, a, e) {
+ var b = "",
+ d = 0;while (b.length < a) {
+ b += hextorstr(e(rstrtohex(c + String.fromCharCode.apply(String, [(d & 4278190080) >> 24, (d & 16711680) >> 16, (d & 65280) >> 8, d & 255]))));d += 1;
+ }return b;
+}RSAKey.prototype.signPSS = function (e, a, d) {
+ var c = function c(f) {
+ return KJUR.crypto.Util.hashHex(f, a);
+ };var b = c(rstrtohex(e));if (d === undefined) {
+ d = -1;
+ }return this.signWithMessageHashPSS(b, a, d);
+};RSAKey.prototype.signWithMessageHashPSS = function (l, a, k) {
+ var b = hextorstr(l);var g = b.length;var m = this.n.bitLength() - 1;var c = Math.ceil(m / 8);var d;var o = function o(i) {
+ return KJUR.crypto.Util.hashHex(i, a);
+ };if (k === -1 || k === undefined) {
+ k = g;
+ } else {
+ if (k === -2) {
+ k = c - g - 2;
+ } else {
+ if (k < -2) {
+ throw new Error("invalid salt length");
+ }
+ }
+ }if (c < g + k + 2) {
+ throw new Error("data too long");
+ }var f = "";if (k > 0) {
+ f = new Array(k);new SecureRandom().nextBytes(f);f = String.fromCharCode.apply(String, f);
+ }var n = hextorstr(o(rstrtohex("\x00\x00\x00\x00\x00\x00\x00\x00" + b + f)));var j = [];for (d = 0; d < c - k - g - 2; d += 1) {
+ j[d] = 0;
+ }var e = String.fromCharCode.apply(String, j) + "\x01" + f;var h = pss_mgf1_str(n, e.length, o);var q = [];for (d = 0; d < e.length; d += 1) {
+ q[d] = e.charCodeAt(d) ^ h.charCodeAt(d);
+ }var p = 65280 >> 8 * c - m & 255;q[0] &= ~p;for (d = 0; d < g; d++) {
+ q.push(n.charCodeAt(d));
+ }q.push(188);return _zeroPaddingOfSignature(this.doPrivate(new BigInteger(q)).toString(16), this.n.bitLength());
+};function _rsasign_getDecryptSignatureBI(a, d, c) {
+ var b = new RSAKey();b.setPublic(d, c);var e = b.doPublic(a);return e;
+}function _rsasign_getHexDigestInfoFromSig(a, c, b) {
+ var e = _rsasign_getDecryptSignatureBI(a, c, b);var d = e.toString(16).replace(/^1f+00/, "");return d;
+}function _rsasign_getAlgNameAndHashFromHexDisgestInfo(f) {
+ for (var e in KJUR.crypto.Util.DIGESTINFOHEAD) {
+ var d = KJUR.crypto.Util.DIGESTINFOHEAD[e];var b = d.length;if (f.substring(0, b) == d) {
+ var c = [e, f.substring(b)];return c;
+ }
+ }return [];
+}RSAKey.prototype.verify = function (f, l) {
+ l = l.toLowerCase();if (l.match(/^[0-9a-f]+$/) == null) {
+ return false;
+ }var b = parseBigInt(l, 16);var k = this.n.bitLength();if (b.bitLength() > k) {
+ return false;
+ }var j = this.doPublic(b);var i = j.toString(16);if (i.length + 3 != k / 4) {
+ return false;
+ }var e = i.replace(/^1f+00/, "");var g = _rsasign_getAlgNameAndHashFromHexDisgestInfo(e);if (g.length == 0) {
+ return false;
+ }var d = g[0];var h = g[1];var a = function a(m) {
+ return KJUR.crypto.Util.hashString(m, d);
+ };var c = a(f);return h == c;
+};RSAKey.prototype.verifyWithMessageHash = function (e, a) {
+ if (a.length != Math.ceil(this.n.bitLength() / 4)) {
+ return false;
+ }var b = parseBigInt(a, 16);if (b.bitLength() > this.n.bitLength()) {
+ return 0;
+ }var h = this.doPublic(b);var g = h.toString(16).replace(/^1f+00/, "");var c = _rsasign_getAlgNameAndHashFromHexDisgestInfo(g);if (c.length == 0) {
+ return false;
+ }var d = c[0];var f = c[1];return f == e;
+};RSAKey.prototype.verifyPSS = function (c, b, a, f) {
+ var e = function e(g) {
+ return KJUR.crypto.Util.hashHex(g, a);
+ };var d = e(rstrtohex(c));if (f === undefined) {
+ f = -1;
+ }return this.verifyWithMessageHashPSS(d, b, a, f);
+};RSAKey.prototype.verifyWithMessageHashPSS = function (f, s, l, c) {
+ if (s.length != Math.ceil(this.n.bitLength() / 4)) {
+ return false;
+ }var k = new BigInteger(s, 16);var r = function r(i) {
+ return KJUR.crypto.Util.hashHex(i, l);
+ };var j = hextorstr(f);var h = j.length;var g = this.n.bitLength() - 1;var m = Math.ceil(g / 8);var q;if (c === -1 || c === undefined) {
+ c = h;
+ } else {
+ if (c === -2) {
+ c = m - h - 2;
+ } else {
+ if (c < -2) {
+ throw new Error("invalid salt length");
+ }
+ }
+ }if (m < h + c + 2) {
+ throw new Error("data too long");
+ }var a = this.doPublic(k).toByteArray();for (q = 0; q < a.length; q += 1) {
+ a[q] &= 255;
+ }while (a.length < m) {
+ a.unshift(0);
+ }if (a[m - 1] !== 188) {
+ throw new Error("encoded message does not end in 0xbc");
+ }a = String.fromCharCode.apply(String, a);var d = a.substr(0, m - h - 1);var e = a.substr(d.length, h);var p = 65280 >> 8 * m - g & 255;if ((d.charCodeAt(0) & p) !== 0) {
+ throw new Error("bits beyond keysize not zero");
+ }var n = pss_mgf1_str(e, d.length, r);var o = [];for (q = 0; q < d.length; q += 1) {
+ o[q] = d.charCodeAt(q) ^ n.charCodeAt(q);
+ }o[0] &= ~p;var b = m - h - c - 2;for (q = 0; q < b; q += 1) {
+ if (o[q] !== 0) {
+ throw new Error("leftmost octets not zero");
+ }
+ }if (o[b] !== 1) {
+ throw new Error("0x01 marker not found");
+ }return e === hextorstr(r(rstrtohex("\x00\x00\x00\x00\x00\x00\x00\x00" + j + String.fromCharCode.apply(String, o.slice(-c)))));
+};RSAKey.SALT_LEN_HLEN = -1;RSAKey.SALT_LEN_MAX = -2;RSAKey.SALT_LEN_RECOVER = -2;
+function X509(q) {
+ var j = ASN1HEX,
+ n = j.getChildIdx,
+ g = j.getV,
+ b = j.getTLV,
+ c = j.getVbyList,
+ k = j.getVbyListEx,
+ a = j.getTLVbyList,
+ l = j.getTLVbyListEx,
+ h = j.getIdxbyList,
+ e = j.getIdxbyListEx,
+ i = j.getVidx,
+ s = j.getInt,
+ p = j.oidname,
+ m = j.hextooidstr,
+ d = X509,
+ r = pemtohex,
+ f;try {
+ f = KJUR.asn1.x509.AlgorithmIdentifier.PSSNAME2ASN1TLV;
+ } catch (o) {}this.HEX2STAG = { "0c": "utf8", "13": "prn", "16": "ia5", "1a": "vis", "1e": "bmp" };this.hex = null;this.version = 0;this.foffset = 0;this.aExtInfo = null;this.getVersion = function () {
+ if (this.hex === null || this.version !== 0) {
+ return this.version;
+ }var u = a(this.hex, 0, [0, 0]);if (u.substr(0, 2) == "a0") {
+ var v = a(u, 0, [0]);var t = s(v, 0);if (t < 0 || 2 < t) {
+ throw new Error("malformed version field");
+ }this.version = t + 1;return this.version;
+ } else {
+ this.version = 1;this.foffset = -1;return 1;
+ }
+ };this.getSerialNumberHex = function () {
+ return k(this.hex, 0, [0, 0], "02");
+ };this.getSignatureAlgorithmField = function () {
+ var t = l(this.hex, 0, [0, 1]);return this.getAlgorithmIdentifierName(t);
+ };this.getAlgorithmIdentifierName = function (t) {
+ for (var u in f) {
+ if (t === f[u]) {
+ return u;
+ }
+ }return p(k(t, 0, [0], "06"));
+ };this.getIssuer = function () {
+ return this.getX500Name(this.getIssuerHex());
+ };this.getIssuerHex = function () {
+ return a(this.hex, 0, [0, 3 + this.foffset], "30");
+ };this.getIssuerString = function () {
+ var t = this.getIssuer();return t.str;
+ };this.getSubject = function () {
+ return this.getX500Name(this.getSubjectHex());
+ };this.getSubjectHex = function () {
+ return a(this.hex, 0, [0, 5 + this.foffset], "30");
+ };this.getSubjectString = function () {
+ var t = this.getSubject();return t.str;
+ };this.getNotBefore = function () {
+ var t = c(this.hex, 0, [0, 4 + this.foffset, 0]);t = t.replace(/(..)/g, "%$1");t = decodeURIComponent(t);return t;
+ };this.getNotAfter = function () {
+ var t = c(this.hex, 0, [0, 4 + this.foffset, 1]);t = t.replace(/(..)/g, "%$1");t = decodeURIComponent(t);return t;
+ };this.getPublicKeyHex = function () {
+ return j.getTLVbyList(this.hex, 0, [0, 6 + this.foffset], "30");
+ };this.getPublicKeyIdx = function () {
+ return h(this.hex, 0, [0, 6 + this.foffset], "30");
+ };this.getPublicKeyContentIdx = function () {
+ var t = this.getPublicKeyIdx();return h(this.hex, t, [1, 0], "30");
+ };this.getPublicKey = function () {
+ return KEYUTIL.getKey(this.getPublicKeyHex(), null, "pkcs8pub");
+ };this.getSignatureAlgorithmName = function () {
+ var t = a(this.hex, 0, [1], "30");return this.getAlgorithmIdentifierName(t);
+ };this.getSignatureValueHex = function () {
+ return c(this.hex, 0, [2], "03", true);
+ };this.verifySignature = function (v) {
+ var w = this.getSignatureAlgorithmField();var t = this.getSignatureValueHex();var u = a(this.hex, 0, [0], "30");var x = new KJUR.crypto.Signature({ alg: w });x.init(v);x.updateHex(u);return x.verify(t);
+ };this.parseExt = function (C) {
+ var v, t, x;if (C === undefined) {
+ x = this.hex;if (this.version !== 3) {
+ return -1;
+ }v = h(x, 0, [0, 7, 0], "30");t = n(x, v);
+ } else {
+ x = pemtohex(C);var y = h(x, 0, [0, 3, 0, 0], "06");if (g(x, y) != "2a864886f70d01090e") {
+ this.aExtInfo = new Array();return;
+ }v = h(x, 0, [0, 3, 0, 1, 0], "30");t = n(x, v);this.hex = x;
+ }this.aExtInfo = new Array();for (var w = 0; w < t.length; w++) {
+ var A = {};A.critical = false;var z = n(x, t[w]);var u = 0;if (z.length === 3) {
+ A.critical = true;u = 1;
+ }A.oid = j.hextooidstr(c(x, t[w], [0], "06"));var B = h(x, t[w], [1 + u]);A.vidx = i(x, B);this.aExtInfo.push(A);
+ }
+ };this.getExtInfo = function (v) {
+ var t = this.aExtInfo;var w = v;if (!v.match(/^[0-9.]+$/)) {
+ w = KJUR.asn1.x509.OID.name2oid(v);
+ }if (w === "") {
+ return undefined;
+ }for (var u = 0; u < t.length; u++) {
+ if (t[u].oid === w) {
+ return t[u];
+ }
+ }return undefined;
+ };this.getExtBasicConstraints = function (u, y) {
+ if (u === undefined && y === undefined) {
+ var w = this.getExtInfo("basicConstraints");if (w === undefined) {
+ return undefined;
+ }u = b(this.hex, w.vidx);y = w.critical;
+ }var t = { extname: "basicConstraints" };if (y) {
+ t.critical = true;
+ }if (u === "3000") {
+ return t;
+ }if (u === "30030101ff") {
+ t.cA = true;return t;
+ }if (u.substr(0, 12) === "30060101ff02") {
+ var x = g(u, 10);var v = parseInt(x, 16);t.cA = true;t.pathLen = v;return t;
+ }throw new Error("hExtV parse error: " + u);
+ };this.getExtKeyUsage = function (u, w) {
+ if (u === undefined && w === undefined) {
+ var v = this.getExtInfo("keyUsage");if (v === undefined) {
+ return undefined;
+ }u = b(this.hex, v.vidx);w = v.critical;
+ }var t = { extname: "keyUsage" };if (w) {
+ t.critical = true;
+ }t.names = this.getExtKeyUsageString(u).split(",");return t;
+ };this.getExtKeyUsageBin = function (u) {
+ if (u === undefined) {
+ var v = this.getExtInfo("keyUsage");if (v === undefined) {
+ return "";
+ }u = b(this.hex, v.vidx);
+ }if (u.length != 8 && u.length != 10) {
+ throw new Error("malformed key usage value: " + u);
+ }var t = "000000000000000" + parseInt(u.substr(6), 16).toString(2);if (u.length == 8) {
+ t = t.slice(-8);
+ }if (u.length == 10) {
+ t = t.slice(-16);
+ }t = t.replace(/0+$/, "");if (t == "") {
+ t = "0";
+ }return t;
+ };this.getExtKeyUsageString = function (v) {
+ var w = this.getExtKeyUsageBin(v);var t = new Array();for (var u = 0; u < w.length; u++) {
+ if (w.substr(u, 1) == "1") {
+ t.push(X509.KEYUSAGE_NAME[u]);
+ }
+ }return t.join(",");
+ };this.getExtSubjectKeyIdentifier = function (v, x) {
+ if (v === undefined && x === undefined) {
+ var w = this.getExtInfo("subjectKeyIdentifier");if (w === undefined) {
+ return undefined;
+ }v = b(this.hex, w.vidx);x = w.critical;
+ }var t = { extname: "subjectKeyIdentifier" };if (x) {
+ t.critical = true;
+ }var u = g(v, 0);t.kid = { hex: u };return t;
+ };this.getExtAuthorityKeyIdentifier = function (z, x) {
+ if (z === undefined && x === undefined) {
+ var t = this.getExtInfo("authorityKeyIdentifier");if (t === undefined) {
+ return undefined;
+ }z = b(this.hex, t.vidx);x = t.critical;
+ }var A = { extname: "authorityKeyIdentifier" };if (x) {
+ A.critical = true;
+ }var y = n(z, 0);for (var u = 0; u < y.length; u++) {
+ var B = z.substr(y[u], 2);if (B === "80") {
+ A.kid = { hex: g(z, y[u]) };
+ }if (B === "a1") {
+ var w = b(z, y[u]);var v = this.getGeneralNames(w);A.issuer = v[0]["dn"];
+ }if (B === "82") {
+ A.sn = { hex: g(z, y[u]) };
+ }
+ }return A;
+ };this.getExtExtKeyUsage = function (w, y) {
+ if (w === undefined && y === undefined) {
+ var x = this.getExtInfo("extKeyUsage");if (x === undefined) {
+ return undefined;
+ }w = b(this.hex, x.vidx);y = x.critical;
+ }var t = { extname: "extKeyUsage", array: [] };if (y) {
+ t.critical = true;
+ }var u = n(w, 0);for (var v = 0; v < u.length; v++) {
+ t.array.push(p(g(w, u[v])));
+ }return t;
+ };this.getExtExtKeyUsageName = function () {
+ var x = this.getExtInfo("extKeyUsage");if (x === undefined) {
+ return x;
+ }var t = new Array();var w = b(this.hex, x.vidx);if (w === "") {
+ return t;
+ }var u = n(w, 0);for (var v = 0; v < u.length; v++) {
+ t.push(p(g(w, u[v])));
+ }return t;
+ };this.getExtSubjectAltName = function (u, w) {
+ if (u === undefined && w === undefined) {
+ var v = this.getExtInfo("subjectAltName");if (v === undefined) {
+ return undefined;
+ }u = b(this.hex, v.vidx);w = v.critical;
+ }var t = { extname: "subjectAltName", array: [] };if (w) {
+ t.critical = true;
+ }t.array = this.getGeneralNames(u);return t;
+ };this.getExtIssuerAltName = function (u, w) {
+ if (u === undefined && w === undefined) {
+ var v = this.getExtInfo("issuerAltName");if (v === undefined) {
+ return undefined;
+ }u = b(this.hex, v.vidx);w = v.critical;
+ }var t = { extname: "issuerAltName", array: [] };if (w) {
+ t.critical = true;
+ }t.array = this.getGeneralNames(u);return t;
+ };this.getGeneralNames = function (x) {
+ var v = n(x, 0);var t = [];for (var w = 0; w < v.length; w++) {
+ var u = this.getGeneralName(b(x, v[w]));if (u !== undefined) {
+ t.push(u);
+ }
+ }return t;
+ };this.getGeneralName = function (u) {
+ var t = u.substr(0, 2);var w = g(u, 0);var v = hextorstr(w);if (t == "81") {
+ return { rfc822: v };
+ }if (t == "82") {
+ return { dns: v };
+ }if (t == "86") {
+ return { uri: v };
+ }if (t == "87") {
+ return { ip: hextoip(w) };
+ }if (t == "a4") {
+ return { dn: this.getX500Name(w) };
+ }return undefined;
+ };this.getExtSubjectAltName2 = function () {
+ var x, A, z;var y = this.getExtInfo("subjectAltName");if (y === undefined) {
+ return y;
+ }var t = new Array();var w = b(this.hex, y.vidx);var u = n(w, 0);for (var v = 0; v < u.length; v++) {
+ z = w.substr(u[v], 2);x = g(w, u[v]);if (z === "81") {
+ A = hextoutf8(x);t.push(["MAIL", A]);
+ }if (z === "82") {
+ A = hextoutf8(x);t.push(["DNS", A]);
+ }if (z === "84") {
+ A = X509.hex2dn(x, 0);t.push(["DN", A]);
+ }if (z === "86") {
+ A = hextoutf8(x);t.push(["URI", A]);
+ }if (z === "87") {
+ A = hextoip(x);t.push(["IP", A]);
+ }
+ }return t;
+ };this.getExtCRLDistributionPoints = function (x, z) {
+ if (x === undefined && z === undefined) {
+ var y = this.getExtInfo("cRLDistributionPoints");if (y === undefined) {
+ return undefined;
+ }x = b(this.hex, y.vidx);z = y.critical;
+ }var u = { extname: "cRLDistributionPoints", array: [] };if (z) {
+ u.critical = true;
+ }var v = n(x, 0);for (var w = 0; w < v.length; w++) {
+ var t = b(x, v[w]);u.array.push(this.getDistributionPoint(t));
+ }return u;
+ };this.getDistributionPoint = function (y) {
+ var v = {};var w = n(y, 0);for (var x = 0; x < w.length; x++) {
+ var u = y.substr(w[x], 2);var t = b(y, w[x]);if (u == "a0") {
+ v.dpname = this.getDistributionPointName(t);
+ }
+ }return v;
+ };this.getDistributionPointName = function (y) {
+ var v = {};var w = n(y, 0);for (var x = 0; x < w.length; x++) {
+ var u = y.substr(w[x], 2);var t = b(y, w[x]);if (u == "a0") {
+ v.full = this.getGeneralNames(t);
+ }
+ }return v;
+ };this.getExtCRLDistributionPointsURI = function () {
+ var y = this.getExtInfo("cRLDistributionPoints");if (y === undefined) {
+ return y;
+ }var t = new Array();var u = n(this.hex, y.vidx);for (var w = 0; w < u.length; w++) {
+ try {
+ var z = c(this.hex, u[w], [0, 0, 0], "86");var x = hextoutf8(z);t.push(x);
+ } catch (v) {}
+ }return t;
+ };this.getExtAIAInfo = function () {
+ var x = this.getExtInfo("authorityInfoAccess");if (x === undefined) {
+ return x;
+ }var t = { ocsp: [], caissuer: [] };var u = n(this.hex, x.vidx);for (var v = 0; v < u.length; v++) {
+ var y = c(this.hex, u[v], [0], "06");var w = c(this.hex, u[v], [1], "86");if (y === "2b06010505073001") {
+ t.ocsp.push(hextoutf8(w));
+ }if (y === "2b06010505073002") {
+ t.caissuer.push(hextoutf8(w));
+ }
+ }return t;
+ };this.getExtAuthorityInfoAccess = function (A, y) {
+ if (A === undefined && y === undefined) {
+ var t = this.getExtInfo("authorityInfoAccess");if (t === undefined) {
+ return undefined;
+ }A = b(this.hex, t.vidx);y = t.critical;
+ }var B = { extname: "authorityInfoAccess", array: [] };if (y) {
+ B.critical = true;
+ }var z = n(A, 0);for (var u = 0; u < z.length; u++) {
+ var x = k(A, z[u], [0], "06");var v = c(A, z[u], [1], "86");var w = hextoutf8(v);if (x == "2b06010505073001") {
+ B.array.push({ ocsp: w });
+ } else {
+ if (x == "2b06010505073002") {
+ B.array.push({ caissuer: w });
+ } else {
+ throw new Error("unknown method: " + x);
+ }
+ }
+ }return B;
+ };this.getExtCertificatePolicies = function (x, A) {
+ if (x === undefined && A === undefined) {
+ var z = this.getExtInfo("certificatePolicies");if (z === undefined) {
+ return undefined;
+ }x = b(this.hex, z.vidx);A = z.critical;
+ }var t = { extname: "certificatePolicies", array: [] };if (A) {
+ t.critical = true;
+ }var u = n(x, 0);for (var v = 0; v < u.length; v++) {
+ var y = b(x, u[v]);var w = this.getPolicyInformation(y);t.array.push(w);
+ }return t;
+ };this.getPolicyInformation = function (x) {
+ var t = {};var z = c(x, 0, [0], "06");t.policyoid = p(z);var A = e(x, 0, [1], "30");if (A != -1) {
+ t.array = [];var u = n(x, A);for (var v = 0; v < u.length; v++) {
+ var y = b(x, u[v]);var w = this.getPolicyQualifierInfo(y);t.array.push(w);
+ }
+ }return t;
+ };this.getPolicyQualifierInfo = function (u) {
+ var t = {};var v = c(u, 0, [0], "06");if (v === "2b06010505070201") {
+ var x = k(u, 0, [1], "16");t.cps = hextorstr(x);
+ } else {
+ if (v === "2b06010505070202") {
+ var w = a(u, 0, [1], "30");t.unotice = this.getUserNotice(w);
+ }
+ }return t;
+ };this.getUserNotice = function (x) {
+ var u = {};var v = n(x, 0);for (var w = 0; w < v.length; w++) {
+ var t = b(x, v[w]);if (t.substr(0, 2) != "30") {
+ u.exptext = this.getDisplayText(t);
+ }
+ }return u;
+ };this.getDisplayText = function (u) {
+ var v = { "0c": "utf8", "16": "ia5", "1a": "vis", "1e": "bmp" };var t = {};t.type = v[u.substr(0, 2)];t.str = hextorstr(g(u, 0));return t;
+ };this.getExtCRLNumber = function (u, v) {
+ var t = { extname: "cRLNumber" };if (v) {
+ t.critical = true;
+ }if (u.substr(0, 2) == "02") {
+ t.num = { hex: g(u, 0) };return t;
+ }throw new Error("hExtV parse error: " + u);
+ };this.getExtCRLReason = function (u, v) {
+ var t = { extname: "cRLReason" };if (v) {
+ t.critical = true;
+ }if (u.substr(0, 2) == "0a") {
+ t.code = parseInt(g(u, 0), 16);return t;
+ }throw new Error("hExtV parse error: " + u);
+ };this.getExtOcspNonce = function (u, w) {
+ var t = { extname: "ocspNonce" };if (w) {
+ t.critical = true;
+ }var v = g(u, 0);t.hex = v;return t;
+ };this.getExtOcspNoCheck = function (u, v) {
+ var t = { extname: "ocspNoCheck" };if (v) {
+ t.critical = true;
+ }return t;
+ };this.getExtAdobeTimeStamp = function (w, z) {
+ if (w === undefined && z === undefined) {
+ var y = this.getExtInfo("adobeTimeStamp");if (y === undefined) {
+ return undefined;
+ }w = b(this.hex, y.vidx);z = y.critical;
+ }var t = { extname: "adobeTimeStamp" };if (z) {
+ t.critical = true;
+ }var v = n(w, 0);if (v.length > 1) {
+ var A = b(w, v[1]);var u = this.getGeneralName(A);if (u.uri != undefined) {
+ t.uri = u.uri;
+ }
+ }if (v.length > 2) {
+ var x = b(w, v[2]);if (x == "0101ff") {
+ t.reqauth = true;
+ }if (x == "010100") {
+ t.reqauth = false;
+ }
+ }return t;
+ };this.getX500NameRule = function (t) {
+ var A = true;var E = true;var D = false;var u = "";var x = "";var G = null;var B = [];for (var w = 0; w < t.length; w++) {
+ var y = t[w];for (var v = 0; v < y.length; v++) {
+ B.push(y[v]);
+ }
+ }for (var w = 0; w < B.length; w++) {
+ var F = B[w];var H = F.ds;var C = F.value;var z = F.type;u += ":" + H;if (H != "prn" && H != "utf8" && H != "ia5") {
+ return "mixed";
+ }if (H == "ia5") {
+ if (z != "CN") {
+ return "mixed";
+ } else {
+ if (!KJUR.lang.String.isMail(C)) {
+ return "mixed";
+ } else {
+ continue;
+ }
+ }
+ }if (z == "C") {
+ if (H == "prn") {
+ continue;
+ } else {
+ return "mixed";
+ }
+ }x += ":" + H;if (G == null) {
+ G = H;
+ } else {
+ if (G !== H) {
+ return "mixed";
+ }
+ }
+ }if (G == null) {
+ return "prn";
+ } else {
+ return G;
+ }
+ };this.getX500Name = function (v) {
+ var t = this.getX500NameArray(v);var u = this.dnarraytostr(t);return { array: t, str: u };
+ };this.getX500NameArray = function (w) {
+ var t = [];var u = n(w, 0);for (var v = 0; v < u.length; v++) {
+ t.push(this.getRDN(b(w, u[v])));
+ }return t;
+ };this.getRDN = function (w) {
+ var t = [];var u = n(w, 0);for (var v = 0; v < u.length; v++) {
+ t.push(this.getAttrTypeAndValue(b(w, u[v])));
+ }return t;
+ };this.getAttrTypeAndValue = function (v) {
+ var t = { type: null, value: null, ds: null };var u = n(v, 0);var y = c(v, u[0], [], "06");var x = c(v, u[1], []);var w = KJUR.asn1.ASN1Util.oidHexToInt(y);t.type = KJUR.asn1.x509.OID.oid2atype(w);t.ds = this.HEX2STAG[v.substr(u[1], 2)];if (t.ds != "bmp") {
+ t.value = hextoutf8(x);
+ } else {
+ t.value = ucs2hextoutf8(x);
+ }return t;
+ };this.readCertPEM = function (t) {
+ this.readCertHex(r(t));
+ };this.readCertHex = function (t) {
+ this.hex = t;this.getVersion();try {
+ h(this.hex, 0, [0, 7], "a3");this.parseExt();
+ } catch (u) {}
+ };this.getParam = function () {
+ var t = {};t.version = this.getVersion();t.serial = { hex: this.getSerialNumberHex() };t.sigalg = this.getSignatureAlgorithmField();t.issuer = this.getIssuer();t.notbefore = this.getNotBefore();t.notafter = this.getNotAfter();t.subject = this.getSubject();t.sbjpubkey = hextopem(this.getPublicKeyHex(), "PUBLIC KEY");if (this.aExtInfo.length > 0) {
+ t.ext = this.getExtParamArray();
+ }t.sighex = this.getSignatureValueHex();return t;
+ };this.getExtParamArray = function (u) {
+ if (u == undefined) {
+ var w = e(this.hex, 0, [0, "[3]"]);if (w != -1) {
+ u = l(this.hex, 0, [0, "[3]", 0], "30");
+ }
+ }var t = [];var v = n(u, 0);for (var x = 0; x < v.length; x++) {
+ var z = b(u, v[x]);var y = this.getExtParam(z);if (y != null) {
+ t.push(y);
+ }
+ }return t;
+ };this.getExtParam = function (u) {
+ var B = {};var w = n(u, 0);var x = w.length;if (x != 2 && x != 3) {
+ throw new Error("wrong number elements in Extension: " + x + " " + u);
+ }var v = m(c(u, 0, [0], "06"));var z = false;if (x == 3 && a(u, 0, [1]) == "0101ff") {
+ z = true;
+ }var A = a(u, 0, [x - 1, 0]);var y = undefined;if (v == "2.5.29.14") {
+ y = this.getExtSubjectKeyIdentifier(A, z);
+ } else {
+ if (v == "2.5.29.15") {
+ y = this.getExtKeyUsage(A, z);
+ } else {
+ if (v == "2.5.29.17") {
+ y = this.getExtSubjectAltName(A, z);
+ } else {
+ if (v == "2.5.29.18") {
+ y = this.getExtIssuerAltName(A, z);
+ } else {
+ if (v == "2.5.29.19") {
+ y = this.getExtBasicConstraints(A, z);
+ } else {
+ if (v == "2.5.29.31") {
+ y = this.getExtCRLDistributionPoints(A, z);
+ } else {
+ if (v == "2.5.29.32") {
+ y = this.getExtCertificatePolicies(A, z);
+ } else {
+ if (v == "2.5.29.35") {
+ y = this.getExtAuthorityKeyIdentifier(A, z);
+ } else {
+ if (v == "2.5.29.37") {
+ y = this.getExtExtKeyUsage(A, z);
+ } else {
+ if (v == "1.3.6.1.5.5.7.1.1") {
+ y = this.getExtAuthorityInfoAccess(A, z);
+ } else {
+ if (v == "2.5.29.20") {
+ y = this.getExtCRLNumber(A, z);
+ } else {
+ if (v == "2.5.29.21") {
+ y = this.getExtCRLReason(A, z);
+ } else {
+ if (v == "1.3.6.1.5.5.7.48.1.2") {
+ y = this.getExtOcspNonce(A, z);
+ } else {
+ if (v == "1.3.6.1.5.5.7.48.1.5") {
+ y = this.getExtOcspNoCheck(A, z);
+ } else {
+ if (v == "1.2.840.113583.1.1.9.1") {
+ y = this.getExtAdobeTimeStamp(A, z);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }if (y != undefined) {
+ return y;
+ }var t = { extname: v, extn: A };if (z) {
+ t.critical = true;
+ }return t;
+ };this.findExt = function (u, v) {
+ for (var t = 0; t < u.length; t++) {
+ if (u[t].extname == v) {
+ return u[t];
+ }
+ }return null;
+ };this.updateExtCDPFullURI = function (x, t) {
+ var w = this.findExt(x, "cRLDistributionPoints");if (w == null) {
+ return;
+ }if (w.array == undefined) {
+ return;
+ }var z = w.array;for (var v = 0; v < z.length; v++) {
+ if (z[v].dpname == undefined) {
+ continue;
+ }if (z[v].dpname.full == undefined) {
+ continue;
+ }var A = z[v].dpname.full;for (var u = 0; u < A.length; u++) {
+ var y = A[v];if (y.uri == undefined) {
+ continue;
+ }y.uri = t;
+ }
+ }
+ };this.updateExtAIAOCSP = function (x, u) {
+ var w = this.findExt(x, "authorityInfoAccess");if (w == null) {
+ return;
+ }if (w.array == undefined) {
+ return;
+ }var t = w.array;for (var v = 0; v < t.length; v++) {
+ if (t[v].ocsp != undefined) {
+ t[v].ocsp = u;
+ }
+ }
+ };this.updateExtAIACAIssuer = function (x, u) {
+ var w = this.findExt(x, "authorityInfoAccess");if (w == null) {
+ return;
+ }if (w.array == undefined) {
+ return;
+ }var t = w.array;for (var v = 0; v < t.length; v++) {
+ if (t[v].caissuer != undefined) {
+ t[v].caissuer = u;
+ }
+ }
+ };this.dnarraytostr = function (v) {
+ function t(w) {
+ return w.map(function (y) {
+ return u(y).replace(/\+/, "\\+");
+ }).join("+");
+ }function u(w) {
+ return w.type + "=" + w.value;
+ }return "/" + v.map(function (w) {
+ return t(w).replace(/\//, "\\/");
+ }).join("/");
+ };this.getInfo = function () {
+ var u = function u(M) {
+ var L = JSON.stringify(M.array).replace(/[\[\]\{\}\"]/g, "");return L;
+ };var A = function A(R) {
+ var P = "";var L = R.array;for (var O = 0; O < L.length; O++) {
+ var Q = L[O];P += " policy oid: " + Q.policyoid + "\n";if (Q.array === undefined) {
+ continue;
+ }for (var N = 0; N < Q.array.length; N++) {
+ var M = Q.array[N];if (M.cps !== undefined) {
+ P += " cps: " + M.cps + "\n";
+ }
+ }
+ }return P;
+ };var D = function D(P) {
+ var O = "";var L = P.array;for (var N = 0; N < L.length; N++) {
+ var Q = L[N];try {
+ if (Q.dpname.full[0].uri !== undefined) {
+ O += " " + Q.dpname.full[0].uri + "\n";
+ }
+ } catch (M) {}try {
+ if (Q.dname.full[0].dn.hex !== undefined) {
+ O += " " + X509.hex2dn(Q.dpname.full[0].dn.hex) + "\n";
+ }
+ } catch (M) {}
+ }return O;
+ };var B = function B(P) {
+ var O = "";var L = P.array;for (var M = 0; M < L.length; M++) {
+ var N = L[M];if (N.caissuer !== undefined) {
+ O += " caissuer: " + N.caissuer + "\n";
+ }if (N.ocsp !== undefined) {
+ O += " ocsp: " + N.ocsp + "\n";
+ }
+ }return O;
+ };var v = X509;var F, E, K;F = "Basic Fields\n";F += " serial number: " + this.getSerialNumberHex() + "\n";F += " signature algorithm: " + this.getSignatureAlgorithmField() + "\n";F += " issuer: " + this.getIssuerString() + "\n";F += " notBefore: " + this.getNotBefore() + "\n";F += " notAfter: " + this.getNotAfter() + "\n";F += " subject: " + this.getSubjectString() + "\n";F += " subject public key info: \n";E = this.getPublicKey();F += " key algorithm: " + E.type + "\n";if (E.type === "RSA") {
+ F += " n=" + hextoposhex(E.n.toString(16)).substr(0, 16) + "...\n";F += " e=" + hextoposhex(E.e.toString(16)) + "\n";
+ }K = this.aExtInfo;if (K !== undefined && K !== null) {
+ F += "X509v3 Extensions:\n";for (var H = 0; H < K.length; H++) {
+ var J = K[H];var t = KJUR.asn1.x509.OID.oid2name(J.oid);if (t === "") {
+ t = J.oid;
+ }var G = "";if (J.critical === true) {
+ G = "CRITICAL";
+ }F += " " + t + " " + G + ":\n";if (t === "basicConstraints") {
+ var w = this.getExtBasicConstraints();if (w.cA === undefined) {
+ F += " {}\n";
+ } else {
+ F += " cA=true";if (w.pathLen !== undefined) {
+ F += ", pathLen=" + w.pathLen;
+ }F += "\n";
+ }
+ } else {
+ if (t === "keyUsage") {
+ F += " " + this.getExtKeyUsageString() + "\n";
+ } else {
+ if (t === "subjectKeyIdentifier") {
+ F += " " + this.getExtSubjectKeyIdentifier().kid.hex + "\n";
+ } else {
+ if (t === "authorityKeyIdentifier") {
+ var x = this.getExtAuthorityKeyIdentifier();if (x.kid !== undefined) {
+ F += " kid=" + x.kid.hex + "\n";
+ }
+ } else {
+ if (t === "extKeyUsage") {
+ var I = this.getExtExtKeyUsage().array;F += " " + I.join(", ") + "\n";
+ } else {
+ if (t === "subjectAltName") {
+ var y = u(this.getExtSubjectAltName());F += " " + y + "\n";
+ } else {
+ if (t === "cRLDistributionPoints") {
+ var C = this.getExtCRLDistributionPoints();F += D(C);
+ } else {
+ if (t === "authorityInfoAccess") {
+ var z = this.getExtAuthorityInfoAccess();F += B(z);
+ } else {
+ if (t === "certificatePolicies") {
+ F += A(this.getExtCertificatePolicies());
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }F += "signature algorithm: " + this.getSignatureAlgorithmName() + "\n";F += "signature: " + this.getSignatureValueHex().substr(0, 16) + "...\n";return F;
+ };if (typeof q == "string") {
+ if (q.indexOf("-----BEGIN") != -1) {
+ this.readCertPEM(q);
+ } else {
+ if (KJUR.lang.String.isHex(q)) {
+ this.readCertHex(q);
+ }
+ }
+ }
+}X509.hex2dn = function (e, b) {
+ if (b === undefined) {
+ b = 0;
+ }var a = new X509();var c = ASN1HEX.getTLV(e, b);var d = a.getX500Name(e);return d.str;
+};X509.hex2rdn = function (f, b) {
+ if (b === undefined) {
+ b = 0;
+ }if (f.substr(b, 2) !== "31") {
+ throw new Error("malformed RDN");
+ }var c = new Array();var d = ASN1HEX.getChildIdx(f, b);for (var e = 0; e < d.length; e++) {
+ c.push(X509.hex2attrTypeValue(f, d[e]));
+ }c = c.map(function (a) {
+ return a.replace("+", "\\+");
+ });return c.join("+");
+};X509.hex2attrTypeValue = function (d, i) {
+ var j = ASN1HEX;var h = j.getV;if (i === undefined) {
+ i = 0;
+ }if (d.substr(i, 2) !== "30") {
+ throw new Error("malformed attribute type and value");
+ }var g = j.getChildIdx(d, i);if (g.length !== 2 || d.substr(g[0], 2) !== "06") {
+ "malformed attribute type and value";
+ }var b = h(d, g[0]);var f = KJUR.asn1.ASN1Util.oidHexToInt(b);var e = KJUR.asn1.x509.OID.oid2atype(f);var a = h(d, g[1]);var c = hextorstr(a);return e + "=" + c;
+};X509.getPublicKeyFromCertHex = function (b) {
+ var a = new X509();a.readCertHex(b);return a.getPublicKey();
+};X509.getPublicKeyFromCertPEM = function (b) {
+ var a = new X509();a.readCertPEM(b);return a.getPublicKey();
+};X509.getPublicKeyInfoPropOfCertPEM = function (c) {
+ var e = ASN1HEX;var g = e.getVbyList;var b = {};var a, f, d;b.algparam = null;a = new X509();a.readCertPEM(c);f = a.getPublicKeyHex();b.keyhex = g(f, 0, [1], "03").substr(2);b.algoid = g(f, 0, [0, 0], "06");if (b.algoid === "2a8648ce3d0201") {
+ b.algparam = g(f, 0, [0, 1], "06");
+ }return b;
+};X509.KEYUSAGE_NAME = ["digitalSignature", "nonRepudiation", "keyEncipherment", "dataEncipherment", "keyAgreement", "keyCertSign", "cRLSign", "encipherOnly", "decipherOnly"];
+if (typeof KJUR == "undefined" || !KJUR) {
+ exports.KJUR = KJUR = {};
+}if (typeof KJUR.jws == "undefined" || !KJUR.jws) {
+ KJUR.jws = {};
+}KJUR.jws.JWS = function () {
+ var b = KJUR,
+ a = b.jws.JWS,
+ c = a.isSafeJSONString;this.parseJWS = function (g, j) {
+ if (this.parsedJWS !== undefined && (j || this.parsedJWS.sigvalH !== undefined)) {
+ return;
+ }var i = g.match(/^([^.]+)\.([^.]+)\.([^.]+)$/);if (i == null) {
+ throw "JWS signature is not a form of 'Head.Payload.SigValue'.";
+ }var k = i[1];var e = i[2];var l = i[3];var n = k + "." + e;this.parsedJWS = {};this.parsedJWS.headB64U = k;this.parsedJWS.payloadB64U = e;this.parsedJWS.sigvalB64U = l;this.parsedJWS.si = n;if (!j) {
+ var h = b64utohex(l);var f = parseBigInt(h, 16);this.parsedJWS.sigvalH = h;this.parsedJWS.sigvalBI = f;
+ }var d = b64utoutf8(k);var m = b64utoutf8(e);this.parsedJWS.headS = d;this.parsedJWS.payloadS = m;if (!c(d, this.parsedJWS, "headP")) {
+ throw "malformed JSON string for JWS Head: " + d;
+ }
+ };
+};KJUR.jws.JWS.sign = function (j, w, z, A, a) {
+ var x = KJUR,
+ n = x.jws,
+ r = n.JWS,
+ h = r.readSafeJSONString,
+ q = r.isSafeJSONString,
+ d = x.crypto,
+ l = d.ECDSA,
+ p = d.Mac,
+ c = d.Signature,
+ u = JSON;var t, k, o;if (typeof w != "string" && (typeof w === "undefined" ? "undefined" : _typeof(w)) != "object") {
+ throw "spHeader must be JSON string or object: " + w;
+ }if ((typeof w === "undefined" ? "undefined" : _typeof(w)) == "object") {
+ k = w;t = u.stringify(k);
+ }if (typeof w == "string") {
+ t = w;if (!q(t)) {
+ throw "JWS Head is not safe JSON string: " + t;
+ }k = h(t);
+ }o = z;if ((typeof z === "undefined" ? "undefined" : _typeof(z)) == "object") {
+ o = u.stringify(z);
+ }if ((j == "" || j == null) && k.alg !== undefined) {
+ j = k.alg;
+ }if (j != "" && j != null && k.alg === undefined) {
+ k.alg = j;t = u.stringify(k);
+ }if (j !== k.alg) {
+ throw "alg and sHeader.alg doesn't match: " + j + "!=" + k.alg;
+ }var s = null;if (r.jwsalg2sigalg[j] === undefined) {
+ throw "unsupported alg name: " + j;
+ } else {
+ s = r.jwsalg2sigalg[j];
+ }var e = utf8tob64u(t);var m = utf8tob64u(o);var b = e + "." + m;var y = "";if (s.substr(0, 4) == "Hmac") {
+ if (A === undefined) {
+ throw "mac key shall be specified for HS* alg";
+ }var i = new p({ alg: s, prov: "cryptojs", pass: A });i.updateString(b);y = i.doFinal();
+ } else {
+ if (s.indexOf("withECDSA") != -1) {
+ var f = new c({ alg: s });f.init(A, a);f.updateString(b);var g = f.sign();y = KJUR.crypto.ECDSA.asn1SigToConcatSig(g);
+ } else {
+ if (s != "none") {
+ var f = new c({ alg: s });f.init(A, a);f.updateString(b);y = f.sign();
+ }
+ }
+ }var v = hextob64u(y);return b + "." + v;
+};KJUR.jws.JWS.verify = function (w, B, n) {
+ var x = KJUR,
+ q = x.jws,
+ t = q.JWS,
+ i = t.readSafeJSONString,
+ e = x.crypto,
+ p = e.ECDSA,
+ s = e.Mac,
+ d = e.Signature,
+ m;if ((typeof RSAKey === "undefined" ? "undefined" : _typeof(RSAKey)) !== undefined) {
+ m = RSAKey;
+ }var y = w.split(".");if (y.length !== 3) {
+ return false;
+ }var f = y[0];var r = y[1];var c = f + "." + r;var A = b64utohex(y[2]);var l = i(b64utoutf8(y[0]));var k = null;var z = null;if (l.alg === undefined) {
+ throw "algorithm not specified in header";
+ } else {
+ k = l.alg;z = k.substr(0, 2);
+ }if (n != null && Object.prototype.toString.call(n) === "[object Array]" && n.length > 0) {
+ var b = ":" + n.join(":") + ":";if (b.indexOf(":" + k + ":") == -1) {
+ throw "algorithm '" + k + "' not accepted in the list";
+ }
+ }if (k != "none" && B === null) {
+ throw "key shall be specified to verify.";
+ }if (typeof B == "string" && B.indexOf("-----BEGIN ") != -1) {
+ B = KEYUTIL.getKey(B);
+ }if (z == "RS" || z == "PS") {
+ if (!(B instanceof m)) {
+ throw "key shall be a RSAKey obj for RS* and PS* algs";
+ }
+ }if (z == "ES") {
+ if (!(B instanceof p)) {
+ throw "key shall be a ECDSA obj for ES* algs";
+ }
+ }if (k == "none") {}var u = null;if (t.jwsalg2sigalg[l.alg] === undefined) {
+ throw "unsupported alg name: " + k;
+ } else {
+ u = t.jwsalg2sigalg[k];
+ }if (u == "none") {
+ throw "not supported";
+ } else {
+ if (u.substr(0, 4) == "Hmac") {
+ var o = null;if (B === undefined) {
+ throw "hexadecimal key shall be specified for HMAC";
+ }var j = new s({ alg: u, pass: B });j.updateString(c);o = j.doFinal();return A == o;
+ } else {
+ if (u.indexOf("withECDSA") != -1) {
+ var h = null;try {
+ h = p.concatSigToASN1Sig(A);
+ } catch (v) {
+ return false;
+ }var g = new d({ alg: u });g.init(B);g.updateString(c);return g.verify(h);
+ } else {
+ var g = new d({ alg: u });g.init(B);g.updateString(c);return g.verify(A);
+ }
+ }
+ }
+};KJUR.jws.JWS.parse = function (g) {
+ var c = g.split(".");var b = {};var f, e, d;if (c.length != 2 && c.length != 3) {
+ throw "malformed sJWS: wrong number of '.' splitted elements";
+ }f = c[0];e = c[1];if (c.length == 3) {
+ d = c[2];
+ }b.headerObj = KJUR.jws.JWS.readSafeJSONString(b64utoutf8(f));b.payloadObj = KJUR.jws.JWS.readSafeJSONString(b64utoutf8(e));b.headerPP = JSON.stringify(b.headerObj, null, " ");if (b.payloadObj == null) {
+ b.payloadPP = b64utoutf8(e);
+ } else {
+ b.payloadPP = JSON.stringify(b.payloadObj, null, " ");
+ }if (d !== undefined) {
+ b.sigHex = b64utohex(d);
+ }return b;
+};KJUR.jws.JWS.verifyJWT = function (e, l, r) {
+ var d = KJUR,
+ j = d.jws,
+ o = j.JWS,
+ n = o.readSafeJSONString,
+ p = o.inArray,
+ f = o.includedArray;var k = e.split(".");var c = k[0];var i = k[1];var q = c + "." + i;var m = b64utohex(k[2]);var h = n(b64utoutf8(c));var g = n(b64utoutf8(i));if (h.alg === undefined) {
+ return false;
+ }if (r.alg === undefined) {
+ throw "acceptField.alg shall be specified";
+ }if (!p(h.alg, r.alg)) {
+ return false;
+ }if (g.iss !== undefined && _typeof(r.iss) === "object") {
+ if (!p(g.iss, r.iss)) {
+ return false;
+ }
+ }if (g.sub !== undefined && _typeof(r.sub) === "object") {
+ if (!p(g.sub, r.sub)) {
+ return false;
+ }
+ }if (g.aud !== undefined && _typeof(r.aud) === "object") {
+ if (typeof g.aud == "string") {
+ if (!p(g.aud, r.aud)) {
+ return false;
+ }
+ } else {
+ if (_typeof(g.aud) == "object") {
+ if (!f(g.aud, r.aud)) {
+ return false;
+ }
+ }
+ }
+ }var b = j.IntDate.getNow();if (r.verifyAt !== undefined && typeof r.verifyAt === "number") {
+ b = r.verifyAt;
+ }if (r.gracePeriod === undefined || typeof r.gracePeriod !== "number") {
+ r.gracePeriod = 0;
+ }if (g.exp !== undefined && typeof g.exp == "number") {
+ if (g.exp + r.gracePeriod < b) {
+ return false;
+ }
+ }if (g.nbf !== undefined && typeof g.nbf == "number") {
+ if (b < g.nbf - r.gracePeriod) {
+ return false;
+ }
+ }if (g.iat !== undefined && typeof g.iat == "number") {
+ if (b < g.iat - r.gracePeriod) {
+ return false;
+ }
+ }if (g.jti !== undefined && r.jti !== undefined) {
+ if (g.jti !== r.jti) {
+ return false;
+ }
+ }if (!o.verify(e, l, r.alg)) {
+ return false;
+ }return true;
+};KJUR.jws.JWS.includedArray = function (b, a) {
+ var c = KJUR.jws.JWS.inArray;if (b === null) {
+ return false;
+ }if ((typeof b === "undefined" ? "undefined" : _typeof(b)) !== "object") {
+ return false;
+ }if (typeof b.length !== "number") {
+ return false;
+ }for (var d = 0; d < b.length; d++) {
+ if (!c(b[d], a)) {
+ return false;
+ }
+ }return true;
+};KJUR.jws.JWS.inArray = function (d, b) {
+ if (b === null) {
+ return false;
+ }if ((typeof b === "undefined" ? "undefined" : _typeof(b)) !== "object") {
+ return false;
+ }if (typeof b.length !== "number") {
+ return false;
+ }for (var c = 0; c < b.length; c++) {
+ if (b[c] == d) {
+ return true;
+ }
+ }return false;
+};KJUR.jws.JWS.jwsalg2sigalg = { HS256: "HmacSHA256", HS384: "HmacSHA384", HS512: "HmacSHA512", RS256: "SHA256withRSA", RS384: "SHA384withRSA", RS512: "SHA512withRSA", ES256: "SHA256withECDSA", ES384: "SHA384withECDSA", PS256: "SHA256withRSAandMGF1", PS384: "SHA384withRSAandMGF1", PS512: "SHA512withRSAandMGF1", none: "none" };KJUR.jws.JWS.isSafeJSONString = function (c, b, d) {
+ var e = null;try {
+ e = jsonParse(c);if ((typeof e === "undefined" ? "undefined" : _typeof(e)) != "object") {
+ return 0;
+ }if (e.constructor === Array) {
+ return 0;
+ }if (b) {
+ b[d] = e;
+ }return 1;
+ } catch (a) {
+ return 0;
+ }
+};KJUR.jws.JWS.readSafeJSONString = function (b) {
+ var c = null;try {
+ c = jsonParse(b);if ((typeof c === "undefined" ? "undefined" : _typeof(c)) != "object") {
+ return null;
+ }if (c.constructor === Array) {
+ return null;
+ }return c;
+ } catch (a) {
+ return null;
+ }
+};KJUR.jws.JWS.getEncodedSignatureValueFromJWS = function (b) {
+ var a = b.match(/^[^.]+\.[^.]+\.([^.]+)$/);if (a == null) {
+ throw "JWS signature is not a form of 'Head.Payload.SigValue'.";
+ }return a[1];
+};KJUR.jws.JWS.getJWKthumbprint = function (d) {
+ if (d.kty !== "RSA" && d.kty !== "EC" && d.kty !== "oct") {
+ throw "unsupported algorithm for JWK Thumprint";
+ }var a = "{";if (d.kty === "RSA") {
+ if (typeof d.n != "string" || typeof d.e != "string") {
+ throw "wrong n and e value for RSA key";
+ }a += '"e":"' + d.e + '",';a += '"kty":"' + d.kty + '",';a += '"n":"' + d.n + '"}';
+ } else {
+ if (d.kty === "EC") {
+ if (typeof d.crv != "string" || typeof d.x != "string" || typeof d.y != "string") {
+ throw "wrong crv, x and y value for EC key";
+ }a += '"crv":"' + d.crv + '",';a += '"kty":"' + d.kty + '",';a += '"x":"' + d.x + '",';a += '"y":"' + d.y + '"}';
+ } else {
+ if (d.kty === "oct") {
+ if (typeof d.k != "string") {
+ throw "wrong k value for oct(symmetric) key";
+ }a += '"kty":"' + d.kty + '",';a += '"k":"' + d.k + '"}';
+ }
+ }
+ }var b = rstrtohex(a);var c = KJUR.crypto.Util.hashHex(b, "sha256");var e = hextob64u(c);return e;
+};KJUR.jws.IntDate = {};KJUR.jws.IntDate.get = function (c) {
+ var b = KJUR.jws.IntDate,
+ d = b.getNow,
+ a = b.getZulu;if (c == "now") {
+ return d();
+ } else {
+ if (c == "now + 1hour") {
+ return d() + 60 * 60;
+ } else {
+ if (c == "now + 1day") {
+ return d() + 60 * 60 * 24;
+ } else {
+ if (c == "now + 1month") {
+ return d() + 60 * 60 * 24 * 30;
+ } else {
+ if (c == "now + 1year") {
+ return d() + 60 * 60 * 24 * 365;
+ } else {
+ if (c.match(/Z$/)) {
+ return a(c);
+ } else {
+ if (c.match(/^[0-9]+$/)) {
+ return parseInt(c);
+ }
+ }
+ }
+ }
+ }
+ }
+ }throw "unsupported format: " + c;
+};KJUR.jws.IntDate.getZulu = function (a) {
+ return zulutosec(a);
+};KJUR.jws.IntDate.getNow = function () {
+ var a = ~~(new Date() / 1000);return a;
+};KJUR.jws.IntDate.intDate2UTCString = function (a) {
+ var b = new Date(a * 1000);return b.toUTCString();
+};KJUR.jws.IntDate.intDate2Zulu = function (e) {
+ var i = new Date(e * 1000),
+ h = ("0000" + i.getUTCFullYear()).slice(-4),
+ g = ("00" + (i.getUTCMonth() + 1)).slice(-2),
+ b = ("00" + i.getUTCDate()).slice(-2),
+ a = ("00" + i.getUTCHours()).slice(-2),
+ c = ("00" + i.getUTCMinutes()).slice(-2),
+ f = ("00" + i.getUTCSeconds()).slice(-2);return h + g + b + a + c + f + "Z";
+};
+exports.SecureRandom = SecureRandom;
+exports.rng_seed_time = rng_seed_time;
+exports.BigInteger = BigInteger;
+exports.RSAKey = RSAKey;
+var EDSA = KJUR.crypto.EDSA;
+exports.EDSA = EDSA;
+var DSA = KJUR.crypto.DSA;
+exports.DSA = DSA;
+var Signature = KJUR.crypto.Signature;
+exports.Signature = Signature;
+var MessageDigest = KJUR.crypto.MessageDigest;
+exports.MessageDigest = MessageDigest;
+var Mac = KJUR.crypto.Mac;
+exports.Mac = Mac;
+var Cipher = KJUR.crypto.Cipher;
+exports.Cipher = Cipher;
+exports.KEYUTIL = KEYUTIL;
+exports.ASN1HEX = ASN1HEX;
+exports.X509 = X509;
+exports.CryptoJS = CryptoJS;
+
+// ext/base64.js
+
+exports.b64tohex = b64tohex;
+exports.b64toBA = b64toBA;
+
+// base64x.js
+
+exports.stoBA = stoBA;
+exports.BAtos = BAtos;
+exports.BAtohex = BAtohex;
+exports.stohex = stohex;
+exports.stob64 = stob64;
+exports.stob64u = stob64u;
+exports.b64utos = b64utos;
+exports.b64tob64u = b64tob64u;
+exports.b64utob64 = b64utob64;
+exports.hex2b64 = hex2b64;
+exports.hextob64u = hextob64u;
+exports.b64utohex = b64utohex;
+exports.utf8tob64u = utf8tob64u;
+exports.b64utoutf8 = b64utoutf8;
+exports.utf8tob64 = utf8tob64;
+exports.b64toutf8 = b64toutf8;
+exports.utf8tohex = utf8tohex;
+exports.hextoutf8 = hextoutf8;
+exports.hextorstr = hextorstr;
+exports.rstrtohex = rstrtohex;
+exports.hextob64 = hextob64;
+exports.hextob64nl = hextob64nl;
+exports.b64nltohex = b64nltohex;
+exports.hextopem = hextopem;
+exports.pemtohex = pemtohex;
+exports.hextoArrayBuffer = hextoArrayBuffer;
+exports.ArrayBuffertohex = ArrayBuffertohex;
+exports.zulutomsec = zulutomsec;
+exports.zulutosec = zulutosec;
+exports.zulutodate = zulutodate;
+exports.datetozulu = datetozulu;
+exports.uricmptohex = uricmptohex;
+exports.hextouricmp = hextouricmp;
+exports.ipv6tohex = ipv6tohex;
+exports.hextoipv6 = hextoipv6;
+exports.hextoip = hextoip;
+exports.iptohex = iptohex;
+exports.encodeURIComponentAll = encodeURIComponentAll;
+exports.newline_toUnix = newline_toUnix;
+exports.newline_toDos = newline_toDos;
+exports.hextoposhex = hextoposhex;
+exports.intarystrtohex = intarystrtohex;
+exports.strdiffidx = strdiffidx;
+
+// name spaces
+
+exports.KJUR = KJUR;
+
+var _crypto = KJUR.crypto;
+exports.crypto = _crypto;
+var _KJUR = KJUR;
+var asn1 = _KJUR.asn1;
+exports.asn1 = asn1;
+var _KJUR2 = KJUR;
+var jws = _KJUR2.jws;
+exports.jws = jws;
+var _KJUR3 = KJUR;
+var lang = _KJUR3.lang;
+exports.lang = lang;
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node_modules/buffer/index.js */ "./node_modules/buffer/index.js").Buffer))
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/lib/index.js":
+/*!**************************************************!*\
+ !*** ./node_modules/babel-polyfill/lib/index.js ***!
+ \**************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+
+__webpack_require__(/*! core-js/shim */ "./node_modules/babel-polyfill/node_modules/core-js/shim.js");
+
+__webpack_require__(/*! regenerator-runtime/runtime */ "./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js");
+
+__webpack_require__(/*! core-js/fn/regexp/escape */ "./node_modules/babel-polyfill/node_modules/core-js/fn/regexp/escape.js");
+
+if (global._babelPolyfill) {
+ throw new Error("only one instance of babel-polyfill is allowed");
+}
+global._babelPolyfill = true;
+
+var DEFINE_PROPERTY = "defineProperty";
+function define(O, key, value) {
+ O[key] || Object[DEFINE_PROPERTY](O, key, {
+ writable: true,
+ configurable: true,
+ value: value
+ });
+}
+
+define(String.prototype, "padLeft", "".padStart);
+define(String.prototype, "padRight", "".padEnd);
+
+"pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill".split(",").forEach(function (key) {
+ [][key] && define(Array, key, Function.call.bind([][key]));
+});
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/fn/regexp/escape.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/fn/regexp/escape.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ../../modules/core.regexp.escape */ "./node_modules/babel-polyfill/node_modules/core-js/modules/core.regexp.escape.js");
+module.exports = __webpack_require__(/*! ../../modules/_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js").RegExp.escape;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ if (typeof it != 'function') throw TypeError(it + ' is not a function!');
+ return it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-number-value.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_a-number-value.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+module.exports = function (it, msg) {
+ if (typeof it != 'number' && cof(it) != 'Number') throw TypeError(msg);
+ return +it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 22.1.3.31 Array.prototype[@@unscopables]
+var UNSCOPABLES = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('unscopables');
+var ArrayProto = Array.prototype;
+if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js")(ArrayProto, UNSCOPABLES, {});
+module.exports = function (key) {
+ ArrayProto[UNSCOPABLES][key] = true;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_advance-string-index.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_advance-string-index.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var at = __webpack_require__(/*! ./_string-at */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-at.js")(true);
+
+ // `AdvanceStringIndex` abstract operation
+// https://tc39.github.io/ecma262/#sec-advancestringindex
+module.exports = function (S, index, unicode) {
+ return index + (unicode ? at(S, index).length : 1);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (it, Constructor, name, forbiddenField) {
+ if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
+ throw TypeError(name + ': incorrect invocation!');
+ } return it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+module.exports = function (it) {
+ if (!isObject(it)) throw TypeError(it + ' is not an object!');
+ return it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-copy-within.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-copy-within.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
+
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+
+module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {
+ var O = toObject(this);
+ var len = toLength(O.length);
+ var to = toAbsoluteIndex(target, len);
+ var from = toAbsoluteIndex(start, len);
+ var end = arguments.length > 2 ? arguments[2] : undefined;
+ var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);
+ var inc = 1;
+ if (from < to && to < from + count) {
+ inc = -1;
+ from += count - 1;
+ to += count - 1;
+ }
+ while (count-- > 0) {
+ if (from in O) O[to] = O[from];
+ else delete O[to];
+ to += inc;
+ from += inc;
+ } return O;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-fill.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-fill.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
+
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+module.exports = function fill(value /* , start = 0, end = @length */) {
+ var O = toObject(this);
+ var length = toLength(O.length);
+ var aLen = arguments.length;
+ var index = toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length);
+ var end = aLen > 2 ? arguments[2] : undefined;
+ var endPos = end === undefined ? length : toAbsoluteIndex(end, length);
+ while (endPos > index) O[index++] = value;
+ return O;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-from-iterable.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-from-iterable.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+
+module.exports = function (iter, ITERATOR) {
+ var result = [];
+ forOf(iter, false, result.push, result, ITERATOR);
+ return result;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-includes.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-includes.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// false -> Array#indexOf
+// true -> Array#includes
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+module.exports = function (IS_INCLUDES) {
+ return function ($this, el, fromIndex) {
+ var O = toIObject($this);
+ var length = toLength(O.length);
+ var index = toAbsoluteIndex(fromIndex, length);
+ var value;
+ // Array#includes uses SameValueZero equality algorithm
+ // eslint-disable-next-line no-self-compare
+ if (IS_INCLUDES && el != el) while (length > index) {
+ value = O[index++];
+ // eslint-disable-next-line no-self-compare
+ if (value != value) return true;
+ // Array#indexOf ignores holes, Array#includes - not
+ } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
+ if (O[index] === el) return IS_INCLUDES || index || 0;
+ } return !IS_INCLUDES && -1;
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 0 -> Array#forEach
+// 1 -> Array#map
+// 2 -> Array#filter
+// 3 -> Array#some
+// 4 -> Array#every
+// 5 -> Array#find
+// 6 -> Array#findIndex
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var asc = __webpack_require__(/*! ./_array-species-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-create.js");
+module.exports = function (TYPE, $create) {
+ var IS_MAP = TYPE == 1;
+ var IS_FILTER = TYPE == 2;
+ var IS_SOME = TYPE == 3;
+ var IS_EVERY = TYPE == 4;
+ var IS_FIND_INDEX = TYPE == 6;
+ var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+ var create = $create || asc;
+ return function ($this, callbackfn, that) {
+ var O = toObject($this);
+ var self = IObject(O);
+ var f = ctx(callbackfn, that, 3);
+ var length = toLength(self.length);
+ var index = 0;
+ var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
+ var val, res;
+ for (;length > index; index++) if (NO_HOLES || index in self) {
+ val = self[index];
+ res = f(val, index, O);
+ if (TYPE) {
+ if (IS_MAP) result[index] = res; // map
+ else if (res) switch (TYPE) {
+ case 3: return true; // some
+ case 5: return val; // find
+ case 6: return index; // findIndex
+ case 2: result.push(val); // filter
+ } else if (IS_EVERY) return false; // every
+ }
+ }
+ return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-reduce.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-reduce.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+
+module.exports = function (that, callbackfn, aLen, memo, isRight) {
+ aFunction(callbackfn);
+ var O = toObject(that);
+ var self = IObject(O);
+ var length = toLength(O.length);
+ var index = isRight ? length - 1 : 0;
+ var i = isRight ? -1 : 1;
+ if (aLen < 2) for (;;) {
+ if (index in self) {
+ memo = self[index];
+ index += i;
+ break;
+ }
+ index += i;
+ if (isRight ? index < 0 : length <= index) {
+ throw TypeError('Reduce of empty array with no initial value');
+ }
+ }
+ for (;isRight ? index >= 0 : length > index; index += i) if (index in self) {
+ memo = callbackfn(memo, self[index], index, O);
+ }
+ return memo;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-constructor.js":
+/*!************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-constructor.js ***!
+ \************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array.js");
+var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('species');
+
+module.exports = function (original) {
+ var C;
+ if (isArray(original)) {
+ C = original.constructor;
+ // cross-realm fallback
+ if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
+ if (isObject(C)) {
+ C = C[SPECIES];
+ if (C === null) C = undefined;
+ }
+ } return C === undefined ? Array : C;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-create.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-create.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
+var speciesConstructor = __webpack_require__(/*! ./_array-species-constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-constructor.js");
+
+module.exports = function (original, length) {
+ return new (speciesConstructor(original))(length);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_bind.js":
+/*!***************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_bind.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var invoke = __webpack_require__(/*! ./_invoke */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_invoke.js");
+var arraySlice = [].slice;
+var factories = {};
+
+var construct = function (F, len, args) {
+ if (!(len in factories)) {
+ for (var n = [], i = 0; i < len; i++) n[i] = 'a[' + i + ']';
+ // eslint-disable-next-line no-new-func
+ factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
+ } return factories[len](F, args);
+};
+
+module.exports = Function.bind || function bind(that /* , ...args */) {
+ var fn = aFunction(this);
+ var partArgs = arraySlice.call(arguments, 1);
+ var bound = function (/* args... */) {
+ var args = partArgs.concat(arraySlice.call(arguments));
+ return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);
+ };
+ if (isObject(fn.prototype)) bound.prototype = fn.prototype;
+ return bound;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// getting tag from 19.1.3.6 Object.prototype.toString()
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+var TAG = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('toStringTag');
+// ES3 wrong here
+var ARG = cof(function () { return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+ try {
+ return it[key];
+ } catch (e) { /* empty */ }
+};
+
+module.exports = function (it) {
+ var O, T, B;
+ return it === undefined ? 'Undefined' : it === null ? 'Null'
+ // @@toStringTag case
+ : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
+ // builtinTag case
+ : ARG ? cof(O)
+ // ES3 arguments fallback
+ : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var toString = {}.toString;
+
+module.exports = function (it) {
+ return toString.call(it).slice(8, -1);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-strong.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-strong.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var create = __webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js");
+var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js");
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+var $iterDefine = __webpack_require__(/*! ./_iter-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-define.js");
+var step = __webpack_require__(/*! ./_iter-step */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-step.js");
+var setSpecies = __webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js");
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var fastKey = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js").fastKey;
+var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var SIZE = DESCRIPTORS ? '_s' : 'size';
+
+var getEntry = function (that, key) {
+ // fast case
+ var index = fastKey(key);
+ var entry;
+ if (index !== 'F') return that._i[index];
+ // frozen object case
+ for (entry = that._f; entry; entry = entry.n) {
+ if (entry.k == key) return entry;
+ }
+};
+
+module.exports = {
+ getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
+ var C = wrapper(function (that, iterable) {
+ anInstance(that, C, NAME, '_i');
+ that._t = NAME; // collection type
+ that._i = create(null); // index
+ that._f = undefined; // first entry
+ that._l = undefined; // last entry
+ that[SIZE] = 0; // size
+ if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
+ });
+ redefineAll(C.prototype, {
+ // 23.1.3.1 Map.prototype.clear()
+ // 23.2.3.2 Set.prototype.clear()
+ clear: function clear() {
+ for (var that = validate(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {
+ entry.r = true;
+ if (entry.p) entry.p = entry.p.n = undefined;
+ delete data[entry.i];
+ }
+ that._f = that._l = undefined;
+ that[SIZE] = 0;
+ },
+ // 23.1.3.3 Map.prototype.delete(key)
+ // 23.2.3.4 Set.prototype.delete(value)
+ 'delete': function (key) {
+ var that = validate(this, NAME);
+ var entry = getEntry(that, key);
+ if (entry) {
+ var next = entry.n;
+ var prev = entry.p;
+ delete that._i[entry.i];
+ entry.r = true;
+ if (prev) prev.n = next;
+ if (next) next.p = prev;
+ if (that._f == entry) that._f = next;
+ if (that._l == entry) that._l = prev;
+ that[SIZE]--;
+ } return !!entry;
+ },
+ // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
+ // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
+ forEach: function forEach(callbackfn /* , that = undefined */) {
+ validate(this, NAME);
+ var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
+ var entry;
+ while (entry = entry ? entry.n : this._f) {
+ f(entry.v, entry.k, this);
+ // revert to the last existing entry
+ while (entry && entry.r) entry = entry.p;
+ }
+ },
+ // 23.1.3.7 Map.prototype.has(key)
+ // 23.2.3.7 Set.prototype.has(value)
+ has: function has(key) {
+ return !!getEntry(validate(this, NAME), key);
+ }
+ });
+ if (DESCRIPTORS) dP(C.prototype, 'size', {
+ get: function () {
+ return validate(this, NAME)[SIZE];
+ }
+ });
+ return C;
+ },
+ def: function (that, key, value) {
+ var entry = getEntry(that, key);
+ var prev, index;
+ // change existing entry
+ if (entry) {
+ entry.v = value;
+ // create new entry
+ } else {
+ that._l = entry = {
+ i: index = fastKey(key, true), // <- index
+ k: key, // <- key
+ v: value, // <- value
+ p: prev = that._l, // <- previous entry
+ n: undefined, // <- next entry
+ r: false // <- removed
+ };
+ if (!that._f) that._f = entry;
+ if (prev) prev.n = entry;
+ that[SIZE]++;
+ // add to index
+ if (index !== 'F') that._i[index] = entry;
+ } return that;
+ },
+ getEntry: getEntry,
+ setStrong: function (C, NAME, IS_MAP) {
+ // add .keys, .values, .entries, [@@iterator]
+ // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
+ $iterDefine(C, NAME, function (iterated, kind) {
+ this._t = validate(iterated, NAME); // target
+ this._k = kind; // kind
+ this._l = undefined; // previous
+ }, function () {
+ var that = this;
+ var kind = that._k;
+ var entry = that._l;
+ // revert to the last existing entry
+ while (entry && entry.r) entry = entry.p;
+ // get next entry
+ if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
+ // or finish the iteration
+ that._t = undefined;
+ return step(1);
+ }
+ // return step by kind
+ if (kind == 'keys') return step(0, entry.k);
+ if (kind == 'values') return step(0, entry.v);
+ return step(0, [entry.k, entry.v]);
+ }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
+
+ // add [@@species], 23.1.2.2, 23.2.2.2
+ setSpecies(NAME);
+ }
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-to-json.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-to-json.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/DavidBruant/Map-Set.prototype.toJSON
+var classof = __webpack_require__(/*! ./_classof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js");
+var from = __webpack_require__(/*! ./_array-from-iterable */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-from-iterable.js");
+module.exports = function (NAME) {
+ return function toJSON() {
+ if (classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic");
+ return from(this);
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-weak.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-weak.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js");
+var getWeak = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js").getWeak;
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+var createArrayMethod = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js");
+var $has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var arrayFind = createArrayMethod(5);
+var arrayFindIndex = createArrayMethod(6);
+var id = 0;
+
+// fallback for uncaught frozen keys
+var uncaughtFrozenStore = function (that) {
+ return that._l || (that._l = new UncaughtFrozenStore());
+};
+var UncaughtFrozenStore = function () {
+ this.a = [];
+};
+var findUncaughtFrozen = function (store, key) {
+ return arrayFind(store.a, function (it) {
+ return it[0] === key;
+ });
+};
+UncaughtFrozenStore.prototype = {
+ get: function (key) {
+ var entry = findUncaughtFrozen(this, key);
+ if (entry) return entry[1];
+ },
+ has: function (key) {
+ return !!findUncaughtFrozen(this, key);
+ },
+ set: function (key, value) {
+ var entry = findUncaughtFrozen(this, key);
+ if (entry) entry[1] = value;
+ else this.a.push([key, value]);
+ },
+ 'delete': function (key) {
+ var index = arrayFindIndex(this.a, function (it) {
+ return it[0] === key;
+ });
+ if (~index) this.a.splice(index, 1);
+ return !!~index;
+ }
+};
+
+module.exports = {
+ getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
+ var C = wrapper(function (that, iterable) {
+ anInstance(that, C, NAME, '_i');
+ that._t = NAME; // collection type
+ that._i = id++; // collection id
+ that._l = undefined; // leak store for uncaught frozen objects
+ if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
+ });
+ redefineAll(C.prototype, {
+ // 23.3.3.2 WeakMap.prototype.delete(key)
+ // 23.4.3.3 WeakSet.prototype.delete(value)
+ 'delete': function (key) {
+ if (!isObject(key)) return false;
+ var data = getWeak(key);
+ if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);
+ return data && $has(data, this._i) && delete data[this._i];
+ },
+ // 23.3.3.4 WeakMap.prototype.has(key)
+ // 23.4.3.4 WeakSet.prototype.has(value)
+ has: function has(key) {
+ if (!isObject(key)) return false;
+ var data = getWeak(key);
+ if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);
+ return data && $has(data, this._i);
+ }
+ });
+ return C;
+ },
+ def: function (that, key, value) {
+ var data = getWeak(anObject(key), true);
+ if (data === true) uncaughtFrozenStore(that).set(key, value);
+ else data[that._i] = value;
+ return that;
+ },
+ ufstore: uncaughtFrozenStore
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_collection.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js");
+var meta = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js");
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var $iterDetect = __webpack_require__(/*! ./_iter-detect */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-detect.js");
+var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js");
+var inheritIfRequired = __webpack_require__(/*! ./_inherit-if-required */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_inherit-if-required.js");
+
+module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
+ var Base = global[NAME];
+ var C = Base;
+ var ADDER = IS_MAP ? 'set' : 'add';
+ var proto = C && C.prototype;
+ var O = {};
+ var fixMethod = function (KEY) {
+ var fn = proto[KEY];
+ redefine(proto, KEY,
+ KEY == 'delete' ? function (a) {
+ return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
+ } : KEY == 'has' ? function has(a) {
+ return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
+ } : KEY == 'get' ? function get(a) {
+ return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
+ } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; }
+ : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; }
+ );
+ };
+ if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {
+ new C().entries().next();
+ }))) {
+ // create collection constructor
+ C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
+ redefineAll(C.prototype, methods);
+ meta.NEED = true;
+ } else {
+ var instance = new C();
+ // early implementations not supports chaining
+ var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
+ // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false
+ var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });
+ // most early implementations doesn't supports iterables, most modern - not close it correctly
+ var ACCEPT_ITERABLES = $iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new
+ // for early implementations -0 and +0 not the same
+ var BUGGY_ZERO = !IS_WEAK && fails(function () {
+ // V8 ~ Chromium 42- fails only with 5+ elements
+ var $instance = new C();
+ var index = 5;
+ while (index--) $instance[ADDER](index, index);
+ return !$instance.has(-0);
+ });
+ if (!ACCEPT_ITERABLES) {
+ C = wrapper(function (target, iterable) {
+ anInstance(target, C, NAME);
+ var that = inheritIfRequired(new Base(), target, C);
+ if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
+ return that;
+ });
+ C.prototype = proto;
+ proto.constructor = C;
+ }
+ if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
+ fixMethod('delete');
+ fixMethod('has');
+ IS_MAP && fixMethod('get');
+ }
+ if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
+ // weak collections should not contains .clear method
+ if (IS_WEAK && proto.clear) delete proto.clear;
+ }
+
+ setToStringTag(C, NAME);
+
+ O[NAME] = C;
+ $export($export.G + $export.W + $export.F * (C != Base), O);
+
+ if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
+
+ return C;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js":
+/*!***************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var core = module.exports = { version: '2.6.11' };
+if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_create-property.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_create-property.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+
+module.exports = function (object, index, value) {
+ if (index in object) $defineProperty.f(object, index, createDesc(0, value));
+ else object[index] = value;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// optional / simple context binding
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+module.exports = function (fn, that, length) {
+ aFunction(fn);
+ if (that === undefined) return fn;
+ switch (length) {
+ case 1: return function (a) {
+ return fn.call(that, a);
+ };
+ case 2: return function (a, b) {
+ return fn.call(that, a, b);
+ };
+ case 3: return function (a, b, c) {
+ return fn.call(that, a, b, c);
+ };
+ }
+ return function (/* ...args */) {
+ return fn.apply(that, arguments);
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_date-to-iso-string.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_date-to-iso-string.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var getTime = Date.prototype.getTime;
+var $toISOString = Date.prototype.toISOString;
+
+var lz = function (num) {
+ return num > 9 ? num : '0' + num;
+};
+
+// PhantomJS / old WebKit has a broken implementations
+module.exports = (fails(function () {
+ return $toISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z';
+}) || !fails(function () {
+ $toISOString.call(new Date(NaN));
+})) ? function toISOString() {
+ if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value');
+ var d = this;
+ var y = d.getUTCFullYear();
+ var m = d.getUTCMilliseconds();
+ var s = y < 0 ? '-' : y > 9999 ? '+' : '';
+ return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +
+ '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +
+ 'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +
+ ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
+} : $toISOString;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_date-to-primitive.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_date-to-primitive.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var NUMBER = 'number';
+
+module.exports = function (hint) {
+ if (hint !== 'string' && hint !== NUMBER && hint !== 'default') throw TypeError('Incorrect hint');
+ return toPrimitive(anObject(this), hint != NUMBER);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// 7.2.1 RequireObjectCoercible(argument)
+module.exports = function (it) {
+ if (it == undefined) throw TypeError("Can't call method on " + it);
+ return it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// Thank's IE8 for his funny defineProperty
+module.exports = !__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_dom-create.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_dom-create.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var document = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").document;
+// typeof document.createElement is 'object' in old IE
+var is = isObject(document) && isObject(document.createElement);
+module.exports = function (it) {
+ return is ? document.createElement(it) : {};
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-bug-keys.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-bug-keys.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// IE 8- don't enum bug keys
+module.exports = (
+ 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+).split(',');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-keys.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-keys.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// all enumerable object keys, includes symbols
+var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+var gOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gops.js");
+var pIE = __webpack_require__(/*! ./_object-pie */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js");
+module.exports = function (it) {
+ var result = getKeys(it);
+ var getSymbols = gOPS.f;
+ if (getSymbols) {
+ var symbols = getSymbols(it);
+ var isEnum = pIE.f;
+ var i = 0;
+ var key;
+ while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
+ } return result;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var core = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var PROTOTYPE = 'prototype';
+
+var $export = function (type, name, source) {
+ var IS_FORCED = type & $export.F;
+ var IS_GLOBAL = type & $export.G;
+ var IS_STATIC = type & $export.S;
+ var IS_PROTO = type & $export.P;
+ var IS_BIND = type & $export.B;
+ var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
+ var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
+ var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
+ var key, own, out, exp;
+ if (IS_GLOBAL) source = name;
+ for (key in source) {
+ // contains in native
+ own = !IS_FORCED && target && target[key] !== undefined;
+ // export native or passed
+ out = (own ? target : source)[key];
+ // bind timers to global for call from export context
+ exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+ // extend global
+ if (target) redefine(target, key, out, type & $export.U);
+ // export
+ if (exports[key] != out) hide(exports, key, exp);
+ if (IS_PROTO && expProto[key] != out) expProto[key] = out;
+ }
+};
+global.core = core;
+// type bitmap
+$export.F = 1; // forced
+$export.G = 2; // global
+$export.S = 4; // static
+$export.P = 8; // proto
+$export.B = 16; // bind
+$export.W = 32; // wrap
+$export.U = 64; // safe
+$export.R = 128; // real proto method for `library`
+module.exports = $export;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails-is-regexp.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_fails-is-regexp.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var MATCH = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('match');
+module.exports = function (KEY) {
+ var re = /./;
+ try {
+ '/./'[KEY](re);
+ } catch (e) {
+ try {
+ re[MATCH] = false;
+ return !'/./'[KEY](re);
+ } catch (f) { /* empty */ }
+ } return true;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js":
+/*!****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js ***!
+ \****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (exec) {
+ try {
+ return !!exec();
+ } catch (e) {
+ return true;
+ }
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fix-re-wks.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_fix-re-wks.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+__webpack_require__(/*! ./es6.regexp.exec */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.exec.js");
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+var wks = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js");
+var regexpExec = __webpack_require__(/*! ./_regexp-exec */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec.js");
+
+var SPECIES = wks('species');
+
+var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
+ // #replace needs built-in support for named groups.
+ // #match works fine because it just return the exec results, even if it has
+ // a "grops" property.
+ var re = /./;
+ re.exec = function () {
+ var result = [];
+ result.groups = { a: '7' };
+ return result;
+ };
+ return ''.replace(re, '$') !== '7';
+});
+
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {
+ // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+ var re = /(?:)/;
+ var originalExec = re.exec;
+ re.exec = function () { return originalExec.apply(this, arguments); };
+ var result = 'ab'.split(re);
+ return result.length === 2 && result[0] === 'a' && result[1] === 'b';
+})();
+
+module.exports = function (KEY, length, exec) {
+ var SYMBOL = wks(KEY);
+
+ var DELEGATES_TO_SYMBOL = !fails(function () {
+ // String methods call symbol-named RegEp methods
+ var O = {};
+ O[SYMBOL] = function () { return 7; };
+ return ''[KEY](O) != 7;
+ });
+
+ var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () {
+ // Symbol-named RegExp methods call .exec
+ var execCalled = false;
+ var re = /a/;
+ re.exec = function () { execCalled = true; return null; };
+ if (KEY === 'split') {
+ // RegExp[@@split] doesn't call the regex's exec method, but first creates
+ // a new one. We need to return the patched regex when creating the new one.
+ re.constructor = {};
+ re.constructor[SPECIES] = function () { return re; };
+ }
+ re[SYMBOL]('');
+ return !execCalled;
+ }) : undefined;
+
+ if (
+ !DELEGATES_TO_SYMBOL ||
+ !DELEGATES_TO_EXEC ||
+ (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
+ (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
+ ) {
+ var nativeRegExpMethod = /./[SYMBOL];
+ var fns = exec(
+ defined,
+ SYMBOL,
+ ''[KEY],
+ function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) {
+ if (regexp.exec === regexpExec) {
+ if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
+ // The native String method already delegates to @@method (this
+ // polyfilled function), leasing to infinite recursion.
+ // We avoid it by directly calling the native @@method method.
+ return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
+ }
+ return { done: true, value: nativeMethod.call(str, regexp, arg2) };
+ }
+ return { done: false };
+ }
+ );
+ var strfn = fns[0];
+ var rxfn = fns[1];
+
+ redefine(String.prototype, KEY, strfn);
+ hide(RegExp.prototype, SYMBOL, length == 2
+ // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
+ // 21.2.5.11 RegExp.prototype[@@split](string, limit)
+ ? function (string, arg) { return rxfn.call(string, this, arg); }
+ // 21.2.5.6 RegExp.prototype[@@match](string)
+ // 21.2.5.9 RegExp.prototype[@@search](string)
+ : function (string) { return rxfn.call(string, this); }
+ );
+ }
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js":
+/*!****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js ***!
+ \****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 21.2.5.3 get RegExp.prototype.flags
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+module.exports = function () {
+ var that = anObject(this);
+ var result = '';
+ if (that.global) result += 'g';
+ if (that.ignoreCase) result += 'i';
+ if (that.multiline) result += 'm';
+ if (that.unicode) result += 'u';
+ if (that.sticky) result += 'y';
+ return result;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flatten-into-array.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_flatten-into-array.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
+var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var IS_CONCAT_SPREADABLE = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('isConcatSpreadable');
+
+function flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) {
+ var targetIndex = start;
+ var sourceIndex = 0;
+ var mapFn = mapper ? ctx(mapper, thisArg, 3) : false;
+ var element, spreadable;
+
+ while (sourceIndex < sourceLen) {
+ if (sourceIndex in source) {
+ element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
+
+ spreadable = false;
+ if (isObject(element)) {
+ spreadable = element[IS_CONCAT_SPREADABLE];
+ spreadable = spreadable !== undefined ? !!spreadable : isArray(element);
+ }
+
+ if (spreadable && depth > 0) {
+ targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;
+ } else {
+ if (targetIndex >= 0x1fffffffffffff) throw TypeError();
+ target[targetIndex] = element;
+ }
+
+ targetIndex++;
+ }
+ sourceIndex++;
+ }
+ return targetIndex;
+}
+
+module.exports = flattenIntoArray;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var call = __webpack_require__(/*! ./_iter-call */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-call.js");
+var isArrayIter = __webpack_require__(/*! ./_is-array-iter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array-iter.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var getIterFn = __webpack_require__(/*! ./core.get-iterator-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/core.get-iterator-method.js");
+var BREAK = {};
+var RETURN = {};
+var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
+ var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
+ var f = ctx(fn, that, entries ? 2 : 1);
+ var index = 0;
+ var length, step, iterator, result;
+ if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
+ // fast case for arrays with default iterator
+ if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
+ result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
+ if (result === BREAK || result === RETURN) return result;
+ } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
+ result = call(iterator, f, step.value, entries);
+ if (result === BREAK || result === RETURN) return result;
+ }
+};
+exports.BREAK = BREAK;
+exports.RETURN = RETURN;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_function-to-string.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_function-to-string.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(/*! ./_shared */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js")('native-function-to-string', Function.toString);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global = module.exports = typeof window != 'undefined' && window.Math == Math
+ ? window : typeof self != 'undefined' && self.Math == Math ? self
+ // eslint-disable-next-line no-new-func
+ : Function('return this')();
+if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function (it, key) {
+ return hasOwnProperty.call(it, key);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js":
+/*!***************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+module.exports = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") ? function (object, key, value) {
+ return dP.f(object, key, createDesc(1, value));
+} : function (object, key, value) {
+ object[key] = value;
+ return object;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_html.js":
+/*!***************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_html.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var document = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").document;
+module.exports = document && document.documentElement;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ie8-dom-define.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_ie8-dom-define.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = !__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && !__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return Object.defineProperty(__webpack_require__(/*! ./_dom-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_dom-create.js")('div'), 'a', { get: function () { return 7; } }).a != 7;
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_inherit-if-required.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_inherit-if-required.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var setPrototypeOf = __webpack_require__(/*! ./_set-proto */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-proto.js").set;
+module.exports = function (that, target, C) {
+ var S = target.constructor;
+ var P;
+ if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {
+ setPrototypeOf(that, P);
+ } return that;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_invoke.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_invoke.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// fast apply, http://jsperf.lnkit.com/fast-apply/5
+module.exports = function (fn, args, that) {
+ var un = that === undefined;
+ switch (args.length) {
+ case 0: return un ? fn()
+ : fn.call(that);
+ case 1: return un ? fn(args[0])
+ : fn.call(that, args[0]);
+ case 2: return un ? fn(args[0], args[1])
+ : fn.call(that, args[0], args[1]);
+ case 3: return un ? fn(args[0], args[1], args[2])
+ : fn.call(that, args[0], args[1], args[2]);
+ case 4: return un ? fn(args[0], args[1], args[2], args[3])
+ : fn.call(that, args[0], args[1], args[2], args[3]);
+ } return fn.apply(that, args);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+// eslint-disable-next-line no-prototype-builtins
+module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
+ return cof(it) == 'String' ? it.split('') : Object(it);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array-iter.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array-iter.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// check on default Array iterator
+var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js");
+var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('iterator');
+var ArrayProto = Array.prototype;
+
+module.exports = function (it) {
+ return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.2.2 IsArray(argument)
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+module.exports = Array.isArray || function isArray(arg) {
+ return cof(arg) == 'Array';
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-integer.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_is-integer.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.3 Number.isInteger(number)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var floor = Math.floor;
+module.exports = function isInteger(it) {
+ return !isObject(it) && isFinite(it) && floor(it) === it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-regexp.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_is-regexp.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.2.8 IsRegExp(argument)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+var MATCH = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('match');
+module.exports = function (it) {
+ var isRegExp;
+ return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-call.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-call.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// call something on iterator step with safe closing on error
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+module.exports = function (iterator, fn, value, entries) {
+ try {
+ return entries ? fn(anObject(value)[0], value[1]) : fn(value);
+ // 7.4.6 IteratorClose(iterator, completion)
+ } catch (e) {
+ var ret = iterator['return'];
+ if (ret !== undefined) anObject(ret.call(iterator));
+ throw e;
+ }
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-create.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-create.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var create = __webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js");
+var descriptor = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js");
+var IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+__webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js")(IteratorPrototype, __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('iterator'), function () { return this; });
+
+module.exports = function (Constructor, NAME, next) {
+ Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
+ setToStringTag(Constructor, NAME + ' Iterator');
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-define.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-define.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js");
+var $iterCreate = __webpack_require__(/*! ./_iter-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-create.js");
+var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('iterator');
+var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
+var FF_ITERATOR = '@@iterator';
+var KEYS = 'keys';
+var VALUES = 'values';
+
+var returnThis = function () { return this; };
+
+module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
+ $iterCreate(Constructor, NAME, next);
+ var getMethod = function (kind) {
+ if (!BUGGY && kind in proto) return proto[kind];
+ switch (kind) {
+ case KEYS: return function keys() { return new Constructor(this, kind); };
+ case VALUES: return function values() { return new Constructor(this, kind); };
+ } return function entries() { return new Constructor(this, kind); };
+ };
+ var TAG = NAME + ' Iterator';
+ var DEF_VALUES = DEFAULT == VALUES;
+ var VALUES_BUG = false;
+ var proto = Base.prototype;
+ var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
+ var $default = $native || getMethod(DEFAULT);
+ var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
+ var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
+ var methods, key, IteratorPrototype;
+ // Fix native
+ if ($anyNative) {
+ IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
+ if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
+ // Set @@toStringTag to native iterators
+ setToStringTag(IteratorPrototype, TAG, true);
+ // fix for some old engines
+ if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
+ }
+ }
+ // fix Array#{values, @@iterator}.name in V8 / FF
+ if (DEF_VALUES && $native && $native.name !== VALUES) {
+ VALUES_BUG = true;
+ $default = function values() { return $native.call(this); };
+ }
+ // Define iterator
+ if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
+ hide(proto, ITERATOR, $default);
+ }
+ // Plug for library
+ Iterators[NAME] = $default;
+ Iterators[TAG] = returnThis;
+ if (DEFAULT) {
+ methods = {
+ values: DEF_VALUES ? $default : getMethod(VALUES),
+ keys: IS_SET ? $default : getMethod(KEYS),
+ entries: $entries
+ };
+ if (FORCED) for (key in methods) {
+ if (!(key in proto)) redefine(proto, key, methods[key]);
+ } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
+ }
+ return methods;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-detect.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-detect.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('iterator');
+var SAFE_CLOSING = false;
+
+try {
+ var riter = [7][ITERATOR]();
+ riter['return'] = function () { SAFE_CLOSING = true; };
+ // eslint-disable-next-line no-throw-literal
+ Array.from(riter, function () { throw 2; });
+} catch (e) { /* empty */ }
+
+module.exports = function (exec, skipClosing) {
+ if (!skipClosing && !SAFE_CLOSING) return false;
+ var safe = false;
+ try {
+ var arr = [7];
+ var iter = arr[ITERATOR]();
+ iter.next = function () { return { done: safe = true }; };
+ arr[ITERATOR] = function () { return iter; };
+ exec(arr);
+ } catch (e) { /* empty */ }
+ return safe;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-step.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-step.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (done, value) {
+ return { value: value, done: !!done };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = {};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = false;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-expm1.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_math-expm1.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// 20.2.2.14 Math.expm1(x)
+var $expm1 = Math.expm1;
+module.exports = (!$expm1
+ // Old FF bug
+ || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168
+ // Tor Browser bug
+ || $expm1(-2e-17) != -2e-17
+) ? function expm1(x) {
+ return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;
+} : $expm1;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-fround.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_math-fround.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.16 Math.fround(x)
+var sign = __webpack_require__(/*! ./_math-sign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-sign.js");
+var pow = Math.pow;
+var EPSILON = pow(2, -52);
+var EPSILON32 = pow(2, -23);
+var MAX32 = pow(2, 127) * (2 - EPSILON32);
+var MIN32 = pow(2, -126);
+
+var roundTiesToEven = function (n) {
+ return n + 1 / EPSILON - 1 / EPSILON;
+};
+
+module.exports = Math.fround || function fround(x) {
+ var $abs = Math.abs(x);
+ var $sign = sign(x);
+ var a, result;
+ if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
+ a = (1 + EPSILON32 / EPSILON) * $abs;
+ result = a - (a - $abs);
+ // eslint-disable-next-line no-self-compare
+ if (result > MAX32 || result != result) return $sign * Infinity;
+ return $sign * result;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-log1p.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_math-log1p.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// 20.2.2.20 Math.log1p(x)
+module.exports = Math.log1p || function log1p(x) {
+ return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-scale.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_math-scale.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+module.exports = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) {
+ if (
+ arguments.length === 0
+ // eslint-disable-next-line no-self-compare
+ || x != x
+ // eslint-disable-next-line no-self-compare
+ || inLow != inLow
+ // eslint-disable-next-line no-self-compare
+ || inHigh != inHigh
+ // eslint-disable-next-line no-self-compare
+ || outLow != outLow
+ // eslint-disable-next-line no-self-compare
+ || outHigh != outHigh
+ ) return NaN;
+ if (x === Infinity || x === -Infinity) return x;
+ return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-sign.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_math-sign.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// 20.2.2.28 Math.sign(x)
+module.exports = Math.sign || function sign(x) {
+ // eslint-disable-next-line no-self-compare
+ return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js":
+/*!***************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var META = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js")('meta');
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var setDesc = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var id = 0;
+var isExtensible = Object.isExtensible || function () {
+ return true;
+};
+var FREEZE = !__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return isExtensible(Object.preventExtensions({}));
+});
+var setMeta = function (it) {
+ setDesc(it, META, { value: {
+ i: 'O' + ++id, // object ID
+ w: {} // weak collections IDs
+ } });
+};
+var fastKey = function (it, create) {
+ // return primitive with prefix
+ if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
+ if (!has(it, META)) {
+ // can't set metadata to uncaught frozen object
+ if (!isExtensible(it)) return 'F';
+ // not necessary to add metadata
+ if (!create) return 'E';
+ // add missing metadata
+ setMeta(it);
+ // return object ID
+ } return it[META].i;
+};
+var getWeak = function (it, create) {
+ if (!has(it, META)) {
+ // can't set metadata to uncaught frozen object
+ if (!isExtensible(it)) return true;
+ // not necessary to add metadata
+ if (!create) return false;
+ // add missing metadata
+ setMeta(it);
+ // return hash weak collections IDs
+ } return it[META].w;
+};
+// add metadata on freeze-family methods calling
+var onFreeze = function (it) {
+ if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
+ return it;
+};
+var meta = module.exports = {
+ KEY: META,
+ NEED: false,
+ fastKey: fastKey,
+ getWeak: getWeak,
+ onFreeze: onFreeze
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var Map = __webpack_require__(/*! ./es6.map */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.map.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var shared = __webpack_require__(/*! ./_shared */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js")('metadata');
+var store = shared.store || (shared.store = new (__webpack_require__(/*! ./es6.weak-map */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-map.js"))());
+
+var getOrCreateMetadataMap = function (target, targetKey, create) {
+ var targetMetadata = store.get(target);
+ if (!targetMetadata) {
+ if (!create) return undefined;
+ store.set(target, targetMetadata = new Map());
+ }
+ var keyMetadata = targetMetadata.get(targetKey);
+ if (!keyMetadata) {
+ if (!create) return undefined;
+ targetMetadata.set(targetKey, keyMetadata = new Map());
+ } return keyMetadata;
+};
+var ordinaryHasOwnMetadata = function (MetadataKey, O, P) {
+ var metadataMap = getOrCreateMetadataMap(O, P, false);
+ return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
+};
+var ordinaryGetOwnMetadata = function (MetadataKey, O, P) {
+ var metadataMap = getOrCreateMetadataMap(O, P, false);
+ return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
+};
+var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) {
+ getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
+};
+var ordinaryOwnMetadataKeys = function (target, targetKey) {
+ var metadataMap = getOrCreateMetadataMap(target, targetKey, false);
+ var keys = [];
+ if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); });
+ return keys;
+};
+var toMetaKey = function (it) {
+ return it === undefined || typeof it == 'symbol' ? it : String(it);
+};
+var exp = function (O) {
+ $export($export.S, 'Reflect', O);
+};
+
+module.exports = {
+ store: store,
+ map: getOrCreateMetadataMap,
+ has: ordinaryHasOwnMetadata,
+ get: ordinaryGetOwnMetadata,
+ set: ordinaryDefineOwnMetadata,
+ keys: ordinaryOwnMetadataKeys,
+ key: toMetaKey,
+ exp: exp
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_microtask.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_microtask.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var macrotask = __webpack_require__(/*! ./_task */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_task.js").set;
+var Observer = global.MutationObserver || global.WebKitMutationObserver;
+var process = global.process;
+var Promise = global.Promise;
+var isNode = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js")(process) == 'process';
+
+module.exports = function () {
+ var head, last, notify;
+
+ var flush = function () {
+ var parent, fn;
+ if (isNode && (parent = process.domain)) parent.exit();
+ while (head) {
+ fn = head.fn;
+ head = head.next;
+ try {
+ fn();
+ } catch (e) {
+ if (head) notify();
+ else last = undefined;
+ throw e;
+ }
+ } last = undefined;
+ if (parent) parent.enter();
+ };
+
+ // Node.js
+ if (isNode) {
+ notify = function () {
+ process.nextTick(flush);
+ };
+ // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
+ } else if (Observer && !(global.navigator && global.navigator.standalone)) {
+ var toggle = true;
+ var node = document.createTextNode('');
+ new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
+ notify = function () {
+ node.data = toggle = !toggle;
+ };
+ // environments with maybe non-completely correct, but existent Promise
+ } else if (Promise && Promise.resolve) {
+ // Promise.resolve without an argument throws an error in LG WebOS 2
+ var promise = Promise.resolve(undefined);
+ notify = function () {
+ promise.then(flush);
+ };
+ // for other environments - macrotask based on:
+ // - setImmediate
+ // - MessageChannel
+ // - window.postMessag
+ // - onreadystatechange
+ // - setTimeout
+ } else {
+ notify = function () {
+ // strange IE + webpack dev server bug - use .call(global)
+ macrotask.call(global, flush);
+ };
+ }
+
+ return function (fn) {
+ var task = { fn: fn, next: undefined };
+ if (last) last.next = task;
+ if (!head) {
+ head = task;
+ notify();
+ } last = task;
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_new-promise-capability.js":
+/*!*********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_new-promise-capability.js ***!
+ \*********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 25.4.1.5 NewPromiseCapability(C)
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+
+function PromiseCapability(C) {
+ var resolve, reject;
+ this.promise = new C(function ($$resolve, $$reject) {
+ if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+ resolve = $$resolve;
+ reject = $$reject;
+ });
+ this.resolve = aFunction(resolve);
+ this.reject = aFunction(reject);
+}
+
+module.exports.f = function (C) {
+ return new PromiseCapability(C);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-assign.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-assign.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 19.1.2.1 Object.assign(target, source, ...)
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+var gOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gops.js");
+var pIE = __webpack_require__(/*! ./_object-pie */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js");
+var $assign = Object.assign;
+
+// should work with symbols and should have deterministic property order (V8 bug)
+module.exports = !$assign || __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ var A = {};
+ var B = {};
+ // eslint-disable-next-line no-undef
+ var S = Symbol();
+ var K = 'abcdefghijklmnopqrst';
+ A[S] = 7;
+ K.split('').forEach(function (k) { B[k] = k; });
+ return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
+}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
+ var T = toObject(target);
+ var aLen = arguments.length;
+ var index = 1;
+ var getSymbols = gOPS.f;
+ var isEnum = pIE.f;
+ while (aLen > index) {
+ var S = IObject(arguments[index++]);
+ var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
+ var length = keys.length;
+ var j = 0;
+ var key;
+ while (length > j) {
+ key = keys[j++];
+ if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key];
+ }
+ } return T;
+} : $assign;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var dPs = __webpack_require__(/*! ./_object-dps */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dps.js");
+var enumBugKeys = __webpack_require__(/*! ./_enum-bug-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-bug-keys.js");
+var IE_PROTO = __webpack_require__(/*! ./_shared-key */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared-key.js")('IE_PROTO');
+var Empty = function () { /* empty */ };
+var PROTOTYPE = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var createDict = function () {
+ // Thrash, waste and sodomy: IE GC bug
+ var iframe = __webpack_require__(/*! ./_dom-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_dom-create.js")('iframe');
+ var i = enumBugKeys.length;
+ var lt = '<';
+ var gt = '>';
+ var iframeDocument;
+ iframe.style.display = 'none';
+ __webpack_require__(/*! ./_html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_html.js").appendChild(iframe);
+ iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+ // createDict = iframe.contentWindow.Object;
+ // html.removeChild(iframe);
+ iframeDocument = iframe.contentWindow.document;
+ iframeDocument.open();
+ iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+ iframeDocument.close();
+ createDict = iframeDocument.F;
+ while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
+ return createDict();
+};
+
+module.exports = Object.create || function create(O, Properties) {
+ var result;
+ if (O !== null) {
+ Empty[PROTOTYPE] = anObject(O);
+ result = new Empty();
+ Empty[PROTOTYPE] = null;
+ // add "__proto__" for Object.getPrototypeOf polyfill
+ result[IE_PROTO] = O;
+ } else result = createDict();
+ return Properties === undefined ? result : dPs(result, Properties);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var IE8_DOM_DEFINE = __webpack_require__(/*! ./_ie8-dom-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ie8-dom-define.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var dP = Object.defineProperty;
+
+exports.f = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") ? Object.defineProperty : function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if (IE8_DOM_DEFINE) try {
+ return dP(O, P, Attributes);
+ } catch (e) { /* empty */ }
+ if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
+ if ('value' in Attributes) O[P] = Attributes.value;
+ return O;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dps.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dps.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+
+module.exports = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") ? Object.defineProperties : function defineProperties(O, Properties) {
+ anObject(O);
+ var keys = getKeys(Properties);
+ var length = keys.length;
+ var i = 0;
+ var P;
+ while (length > i) dP.f(O, P = keys[i++], Properties[P]);
+ return O;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-forced-pam.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-forced-pam.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// Forced replacement prototype accessors methods
+module.exports = __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js") || !__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ var K = Math.random();
+ // In FF throws only define methods
+ // eslint-disable-next-line no-undef, no-useless-call
+ __defineSetter__.call(null, K, function () { /* empty */ });
+ delete __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js")[K];
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var pIE = __webpack_require__(/*! ./_object-pie */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js");
+var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var IE8_DOM_DEFINE = __webpack_require__(/*! ./_ie8-dom-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ie8-dom-define.js");
+var gOPD = Object.getOwnPropertyDescriptor;
+
+exports.f = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") ? gOPD : function getOwnPropertyDescriptor(O, P) {
+ O = toIObject(O);
+ P = toPrimitive(P, true);
+ if (IE8_DOM_DEFINE) try {
+ return gOPD(O, P);
+ } catch (e) { /* empty */ }
+ if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn-ext.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn-ext.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js").f;
+var toString = {}.toString;
+
+var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
+ ? Object.getOwnPropertyNames(window) : [];
+
+var getWindowNames = function (it) {
+ try {
+ return gOPN(it);
+ } catch (e) {
+ return windowNames.slice();
+ }
+};
+
+module.exports.f = function getOwnPropertyNames(it) {
+ return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
+var $keys = __webpack_require__(/*! ./_object-keys-internal */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys-internal.js");
+var hiddenKeys = __webpack_require__(/*! ./_enum-bug-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-bug-keys.js").concat('length', 'prototype');
+
+exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+ return $keys(O, hiddenKeys);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gops.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gops.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+exports.f = Object.getOwnPropertySymbols;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var IE_PROTO = __webpack_require__(/*! ./_shared-key */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared-key.js")('IE_PROTO');
+var ObjectProto = Object.prototype;
+
+module.exports = Object.getPrototypeOf || function (O) {
+ O = toObject(O);
+ if (has(O, IE_PROTO)) return O[IE_PROTO];
+ if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+ return O.constructor.prototype;
+ } return O instanceof Object ? ObjectProto : null;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys-internal.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys-internal.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var arrayIndexOf = __webpack_require__(/*! ./_array-includes */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-includes.js")(false);
+var IE_PROTO = __webpack_require__(/*! ./_shared-key */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared-key.js")('IE_PROTO');
+
+module.exports = function (object, names) {
+ var O = toIObject(object);
+ var i = 0;
+ var result = [];
+ var key;
+ for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
+ // Don't enum bug & hidden keys
+ while (names.length > i) if (has(O, key = names[i++])) {
+ ~arrayIndexOf(result, key) || result.push(key);
+ }
+ return result;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys = __webpack_require__(/*! ./_object-keys-internal */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys-internal.js");
+var enumBugKeys = __webpack_require__(/*! ./_enum-bug-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-bug-keys.js");
+
+module.exports = Object.keys || function keys(O) {
+ return $keys(O, enumBugKeys);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+exports.f = {}.propertyIsEnumerable;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// most Object methods by ES6 should accept primitives
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var core = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+module.exports = function (KEY, exec) {
+ var fn = (core.Object || {})[KEY] || Object[KEY];
+ var exp = {};
+ exp[KEY] = exec(fn);
+ $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-to-array.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_object-to-array.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var isEnum = __webpack_require__(/*! ./_object-pie */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js").f;
+module.exports = function (isEntries) {
+ return function (it) {
+ var O = toIObject(it);
+ var keys = getKeys(O);
+ var length = keys.length;
+ var i = 0;
+ var result = [];
+ var key;
+ while (length > i) {
+ key = keys[i++];
+ if (!DESCRIPTORS || isEnum.call(O, key)) {
+ result.push(isEntries ? [key, O[key]] : O[key]);
+ }
+ }
+ return result;
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_own-keys.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_own-keys.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// all object keys, includes non-enumerable and symbols
+var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js");
+var gOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gops.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var Reflect = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").Reflect;
+module.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {
+ var keys = gOPN.f(anObject(it));
+ var getSymbols = gOPS.f;
+ return getSymbols ? keys.concat(getSymbols(it)) : keys;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-float.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-float.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $parseFloat = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").parseFloat;
+var $trim = __webpack_require__(/*! ./_string-trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js").trim;
+
+module.exports = 1 / $parseFloat(__webpack_require__(/*! ./_string-ws */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-ws.js") + '-0') !== -Infinity ? function parseFloat(str) {
+ var string = $trim(String(str), 3);
+ var result = $parseFloat(string);
+ return result === 0 && string.charAt(0) == '-' ? -0 : result;
+} : $parseFloat;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-int.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-int.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $parseInt = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").parseInt;
+var $trim = __webpack_require__(/*! ./_string-trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js").trim;
+var ws = __webpack_require__(/*! ./_string-ws */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-ws.js");
+var hex = /^[-+]?0[xX]/;
+
+module.exports = $parseInt(ws + '08') !== 8 || $parseInt(ws + '0x16') !== 22 ? function parseInt(str, radix) {
+ var string = $trim(String(str), 3);
+ return $parseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10));
+} : $parseInt;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_perform.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_perform.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (exec) {
+ try {
+ return { e: false, v: exec() };
+ } catch (e) {
+ return { e: true, v: e };
+ }
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_promise-resolve.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_promise-resolve.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var newPromiseCapability = __webpack_require__(/*! ./_new-promise-capability */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_new-promise-capability.js");
+
+module.exports = function (C, x) {
+ anObject(C);
+ if (isObject(x) && x.constructor === C) return x;
+ var promiseCapability = newPromiseCapability.f(C);
+ var resolve = promiseCapability.resolve;
+ resolve(x);
+ return promiseCapability.promise;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (bitmap, value) {
+ return {
+ enumerable: !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable: !(bitmap & 4),
+ value: value
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+module.exports = function (target, src, safe) {
+ for (var key in src) redefine(target, key, src[key], safe);
+ return target;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var SRC = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js")('src');
+var $toString = __webpack_require__(/*! ./_function-to-string */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_function-to-string.js");
+var TO_STRING = 'toString';
+var TPL = ('' + $toString).split(TO_STRING);
+
+__webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js").inspectSource = function (it) {
+ return $toString.call(it);
+};
+
+(module.exports = function (O, key, val, safe) {
+ var isFunction = typeof val == 'function';
+ if (isFunction) has(val, 'name') || hide(val, 'name', key);
+ if (O[key] === val) return;
+ if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
+ if (O === global) {
+ O[key] = val;
+ } else if (!safe) {
+ delete O[key];
+ hide(O, key, val);
+ } else if (O[key]) {
+ O[key] = val;
+ } else {
+ hide(O, key, val);
+ }
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+})(Function.prototype, TO_STRING, function toString() {
+ return typeof this == 'function' && this[SRC] || $toString.call(this);
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec-abstract.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec-abstract.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var classof = __webpack_require__(/*! ./_classof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js");
+var builtinExec = RegExp.prototype.exec;
+
+ // `RegExpExec` abstract operation
+// https://tc39.github.io/ecma262/#sec-regexpexec
+module.exports = function (R, S) {
+ var exec = R.exec;
+ if (typeof exec === 'function') {
+ var result = exec.call(R, S);
+ if (typeof result !== 'object') {
+ throw new TypeError('RegExp exec method returned something other than an Object or null');
+ }
+ return result;
+ }
+ if (classof(R) !== 'RegExp') {
+ throw new TypeError('RegExp#exec called on incompatible receiver');
+ }
+ return builtinExec.call(R, S);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var regexpFlags = __webpack_require__(/*! ./_flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js");
+
+var nativeExec = RegExp.prototype.exec;
+// This always refers to the native implementation, because the
+// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
+// which loads this file before patching the method.
+var nativeReplace = String.prototype.replace;
+
+var patchedExec = nativeExec;
+
+var LAST_INDEX = 'lastIndex';
+
+var UPDATES_LAST_INDEX_WRONG = (function () {
+ var re1 = /a/,
+ re2 = /b*/g;
+ nativeExec.call(re1, 'a');
+ nativeExec.call(re2, 'a');
+ return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0;
+})();
+
+// nonparticipating capturing group, copied from es5-shim's String#split patch.
+var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
+
+var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;
+
+if (PATCH) {
+ patchedExec = function exec(str) {
+ var re = this;
+ var lastIndex, reCopy, match, i;
+
+ if (NPCG_INCLUDED) {
+ reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re));
+ }
+ if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX];
+
+ match = nativeExec.call(re, str);
+
+ if (UPDATES_LAST_INDEX_WRONG && match) {
+ re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex;
+ }
+ if (NPCG_INCLUDED && match && match.length > 1) {
+ // Fix browsers whose `exec` methods don't consistently return `undefined`
+ // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
+ // eslint-disable-next-line no-loop-func
+ nativeReplace.call(match[0], reCopy, function () {
+ for (i = 1; i < arguments.length - 2; i++) {
+ if (arguments[i] === undefined) match[i] = undefined;
+ }
+ });
+ }
+
+ return match;
+ };
+}
+
+module.exports = patchedExec;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_replacer.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_replacer.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = function (regExp, replace) {
+ var replacer = replace === Object(replace) ? function (part) {
+ return replace[part];
+ } : replace;
+ return function (it) {
+ return String(it).replace(regExp, replacer);
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_same-value.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_same-value.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// 7.2.9 SameValue(x, y)
+module.exports = Object.is || function is(x, y) {
+ // eslint-disable-next-line no-self-compare
+ return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-from.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-from.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://tc39.github.io/proposal-setmap-offrom/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+
+module.exports = function (COLLECTION) {
+ $export($export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) {
+ var mapFn = arguments[1];
+ var mapping, A, n, cb;
+ aFunction(this);
+ mapping = mapFn !== undefined;
+ if (mapping) aFunction(mapFn);
+ if (source == undefined) return new this();
+ A = [];
+ if (mapping) {
+ n = 0;
+ cb = ctx(mapFn, arguments[2], 2);
+ forOf(source, false, function (nextItem) {
+ A.push(cb(nextItem, n++));
+ });
+ } else {
+ forOf(source, false, A.push, A);
+ }
+ return new this(A);
+ } });
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-of.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-of.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://tc39.github.io/proposal-setmap-offrom/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+module.exports = function (COLLECTION) {
+ $export($export.S, COLLECTION, { of: function of() {
+ var length = arguments.length;
+ var A = new Array(length);
+ while (length--) A[length] = arguments[length];
+ return new this(A);
+ } });
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-proto.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_set-proto.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+/* eslint-disable no-proto */
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var check = function (O, proto) {
+ anObject(O);
+ if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
+};
+module.exports = {
+ set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
+ function (test, buggy, set) {
+ try {
+ set = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js")(Function.call, __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js").f(Object.prototype, '__proto__').set, 2);
+ set(test, []);
+ buggy = !(test instanceof Array);
+ } catch (e) { buggy = true; }
+ return function setPrototypeOf(O, proto) {
+ check(O, proto);
+ if (buggy) O.__proto__ = proto;
+ else set(O, proto);
+ return O;
+ };
+ }({}, false) : undefined),
+ check: check
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('species');
+
+module.exports = function (KEY) {
+ var C = global[KEY];
+ if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
+ configurable: true,
+ get: function () { return this; }
+ });
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var def = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var TAG = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('toStringTag');
+
+module.exports = function (it, tag, stat) {
+ if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared-key.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_shared-key.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var shared = __webpack_require__(/*! ./_shared */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js")('keys');
+var uid = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js");
+module.exports = function (key) {
+ return shared[key] || (shared[key] = uid(key));
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var core = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var SHARED = '__core-js_shared__';
+var store = global[SHARED] || (global[SHARED] = {});
+
+(module.exports = function (key, value) {
+ return store[key] || (store[key] = value !== undefined ? value : {});
+})('versions', []).push({
+ version: core.version,
+ mode: __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js") ? 'pure' : 'global',
+ copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.3.20 SpeciesConstructor(O, defaultConstructor)
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('species');
+module.exports = function (O, D) {
+ var C = anObject(O).constructor;
+ var S;
+ return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+
+module.exports = function (method, arg) {
+ return !!method && fails(function () {
+ // eslint-disable-next-line no-useless-call
+ arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);
+ });
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-at.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-at.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+// true -> String#at
+// false -> String#codePointAt
+module.exports = function (TO_STRING) {
+ return function (that, pos) {
+ var s = String(defined(that));
+ var i = toInteger(pos);
+ var l = s.length;
+ var a, b;
+ if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
+ a = s.charCodeAt(i);
+ return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+ ? TO_STRING ? s.charAt(i) : a
+ : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+ };
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-context.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-context.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// helper for String#{startsWith, endsWith, includes}
+var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-regexp.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+
+module.exports = function (that, searchString, NAME) {
+ if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!");
+ return String(defined(that));
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+var quot = /"/g;
+// B.2.3.2.1 CreateHTML(string, tag, attribute, value)
+var createHTML = function (string, tag, attribute, value) {
+ var S = String(defined(string));
+ var p1 = '<' + tag;
+ if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"';
+ return p1 + '>' + S + '';
+};
+module.exports = function (NAME, exec) {
+ var O = {};
+ O[NAME] = exec(createHTML);
+ $export($export.P + $export.F * fails(function () {
+ var test = ''[NAME]('"');
+ return test !== test.toLowerCase() || test.split('"').length > 3;
+ }), 'String', O);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-pad.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-pad.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/tc39/proposal-string-pad-start-end
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var repeat = __webpack_require__(/*! ./_string-repeat */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-repeat.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+
+module.exports = function (that, maxLength, fillString, left) {
+ var S = String(defined(that));
+ var stringLength = S.length;
+ var fillStr = fillString === undefined ? ' ' : String(fillString);
+ var intMaxLength = toLength(maxLength);
+ if (intMaxLength <= stringLength || fillStr == '') return S;
+ var fillLen = intMaxLength - stringLength;
+ var stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
+ if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);
+ return left ? stringFiller + S : S + stringFiller;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-repeat.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-repeat.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+
+module.exports = function repeat(count) {
+ var str = String(defined(this));
+ var res = '';
+ var n = toInteger(count);
+ if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");
+ for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) res += str;
+ return res;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var spaces = __webpack_require__(/*! ./_string-ws */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-ws.js");
+var space = '[' + spaces + ']';
+var non = '\u200b\u0085';
+var ltrim = RegExp('^' + space + space + '*');
+var rtrim = RegExp(space + space + '*$');
+
+var exporter = function (KEY, exec, ALIAS) {
+ var exp = {};
+ var FORCE = fails(function () {
+ return !!spaces[KEY]() || non[KEY]() != non;
+ });
+ var fn = exp[KEY] = FORCE ? exec(trim) : spaces[KEY];
+ if (ALIAS) exp[ALIAS] = fn;
+ $export($export.P + $export.F * FORCE, 'String', exp);
+};
+
+// 1 -> String#trimLeft
+// 2 -> String#trimRight
+// 3 -> String#trim
+var trim = exporter.trim = function (string, TYPE) {
+ string = String(defined(string));
+ if (TYPE & 1) string = string.replace(ltrim, '');
+ if (TYPE & 2) string = string.replace(rtrim, '');
+ return string;
+};
+
+module.exports = exporter;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-ws.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_string-ws.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
+ '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_task.js":
+/*!***************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_task.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var invoke = __webpack_require__(/*! ./_invoke */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_invoke.js");
+var html = __webpack_require__(/*! ./_html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_html.js");
+var cel = __webpack_require__(/*! ./_dom-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_dom-create.js");
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var process = global.process;
+var setTask = global.setImmediate;
+var clearTask = global.clearImmediate;
+var MessageChannel = global.MessageChannel;
+var Dispatch = global.Dispatch;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var defer, channel, port;
+var run = function () {
+ var id = +this;
+ // eslint-disable-next-line no-prototype-builtins
+ if (queue.hasOwnProperty(id)) {
+ var fn = queue[id];
+ delete queue[id];
+ fn();
+ }
+};
+var listener = function (event) {
+ run.call(event.data);
+};
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if (!setTask || !clearTask) {
+ setTask = function setImmediate(fn) {
+ var args = [];
+ var i = 1;
+ while (arguments.length > i) args.push(arguments[i++]);
+ queue[++counter] = function () {
+ // eslint-disable-next-line no-new-func
+ invoke(typeof fn == 'function' ? fn : Function(fn), args);
+ };
+ defer(counter);
+ return counter;
+ };
+ clearTask = function clearImmediate(id) {
+ delete queue[id];
+ };
+ // Node.js 0.8-
+ if (__webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js")(process) == 'process') {
+ defer = function (id) {
+ process.nextTick(ctx(run, id, 1));
+ };
+ // Sphere (JS game engine) Dispatch API
+ } else if (Dispatch && Dispatch.now) {
+ defer = function (id) {
+ Dispatch.now(ctx(run, id, 1));
+ };
+ // Browsers with MessageChannel, includes WebWorkers
+ } else if (MessageChannel) {
+ channel = new MessageChannel();
+ port = channel.port2;
+ channel.port1.onmessage = listener;
+ defer = ctx(port.postMessage, port, 1);
+ // Browsers with postMessage, skip WebWorkers
+ // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+ } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
+ defer = function (id) {
+ global.postMessage(id + '', '*');
+ };
+ global.addEventListener('message', listener, false);
+ // IE8-
+ } else if (ONREADYSTATECHANGE in cel('script')) {
+ defer = function (id) {
+ html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
+ html.removeChild(this);
+ run.call(id);
+ };
+ };
+ // Rest old browsers
+ } else {
+ defer = function (id) {
+ setTimeout(ctx(run, id, 1), 0);
+ };
+ }
+}
+module.exports = {
+ set: setTask,
+ clear: clearTask
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var max = Math.max;
+var min = Math.min;
+module.exports = function (index, length) {
+ index = toInteger(index);
+ return index < 0 ? max(index + length, 0) : min(index, length);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-index.js":
+/*!*******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-index.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/ecma262/#sec-toindex
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+module.exports = function (it) {
+ if (it === undefined) return 0;
+ var number = toInteger(it);
+ var length = toLength(number);
+ if (number !== length) throw RangeError('Wrong length!');
+ return length;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// 7.1.4 ToInteger
+var ceil = Math.ceil;
+var floor = Math.floor;
+module.exports = function (it) {
+ return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// to indexed object, toObject with fallback for non-array-like ES3 strings
+var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+module.exports = function (it) {
+ return IObject(defined(it));
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.1.15 ToLength
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var min = Math.min;
+module.exports = function (it) {
+ return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.1.13 ToObject(argument)
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+module.exports = function (it) {
+ return Object(defined(it));
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.1.1 ToPrimitive(input [, PreferredType])
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+module.exports = function (it, S) {
+ if (!isObject(it)) return it;
+ var fn, val;
+ if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
+ if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
+ if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
+ throw TypeError("Can't convert object to primitive value");
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+if (__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js")) {
+ var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js");
+ var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+ var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+ var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+ var $typed = __webpack_require__(/*! ./_typed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed.js");
+ var $buffer = __webpack_require__(/*! ./_typed-buffer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-buffer.js");
+ var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+ var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+ var propertyDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+ var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+ var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js");
+ var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+ var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+ var toIndex = __webpack_require__(/*! ./_to-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-index.js");
+ var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+ var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+ var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+ var classof = __webpack_require__(/*! ./_classof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js");
+ var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+ var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+ var isArrayIter = __webpack_require__(/*! ./_is-array-iter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array-iter.js");
+ var create = __webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js");
+ var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+ var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js").f;
+ var getIterFn = __webpack_require__(/*! ./core.get-iterator-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/core.get-iterator-method.js");
+ var uid = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js");
+ var wks = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js");
+ var createArrayMethod = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js");
+ var createArrayIncludes = __webpack_require__(/*! ./_array-includes */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-includes.js");
+ var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js");
+ var ArrayIterators = __webpack_require__(/*! ./es6.array.iterator */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.iterator.js");
+ var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js");
+ var $iterDetect = __webpack_require__(/*! ./_iter-detect */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-detect.js");
+ var setSpecies = __webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js");
+ var arrayFill = __webpack_require__(/*! ./_array-fill */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-fill.js");
+ var arrayCopyWithin = __webpack_require__(/*! ./_array-copy-within */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-copy-within.js");
+ var $DP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+ var $GOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js");
+ var dP = $DP.f;
+ var gOPD = $GOPD.f;
+ var RangeError = global.RangeError;
+ var TypeError = global.TypeError;
+ var Uint8Array = global.Uint8Array;
+ var ARRAY_BUFFER = 'ArrayBuffer';
+ var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER;
+ var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
+ var PROTOTYPE = 'prototype';
+ var ArrayProto = Array[PROTOTYPE];
+ var $ArrayBuffer = $buffer.ArrayBuffer;
+ var $DataView = $buffer.DataView;
+ var arrayForEach = createArrayMethod(0);
+ var arrayFilter = createArrayMethod(2);
+ var arraySome = createArrayMethod(3);
+ var arrayEvery = createArrayMethod(4);
+ var arrayFind = createArrayMethod(5);
+ var arrayFindIndex = createArrayMethod(6);
+ var arrayIncludes = createArrayIncludes(true);
+ var arrayIndexOf = createArrayIncludes(false);
+ var arrayValues = ArrayIterators.values;
+ var arrayKeys = ArrayIterators.keys;
+ var arrayEntries = ArrayIterators.entries;
+ var arrayLastIndexOf = ArrayProto.lastIndexOf;
+ var arrayReduce = ArrayProto.reduce;
+ var arrayReduceRight = ArrayProto.reduceRight;
+ var arrayJoin = ArrayProto.join;
+ var arraySort = ArrayProto.sort;
+ var arraySlice = ArrayProto.slice;
+ var arrayToString = ArrayProto.toString;
+ var arrayToLocaleString = ArrayProto.toLocaleString;
+ var ITERATOR = wks('iterator');
+ var TAG = wks('toStringTag');
+ var TYPED_CONSTRUCTOR = uid('typed_constructor');
+ var DEF_CONSTRUCTOR = uid('def_constructor');
+ var ALL_CONSTRUCTORS = $typed.CONSTR;
+ var TYPED_ARRAY = $typed.TYPED;
+ var VIEW = $typed.VIEW;
+ var WRONG_LENGTH = 'Wrong length!';
+
+ var $map = createArrayMethod(1, function (O, length) {
+ return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
+ });
+
+ var LITTLE_ENDIAN = fails(function () {
+ // eslint-disable-next-line no-undef
+ return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+ });
+
+ var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () {
+ new Uint8Array(1).set({});
+ });
+
+ var toOffset = function (it, BYTES) {
+ var offset = toInteger(it);
+ if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!');
+ return offset;
+ };
+
+ var validate = function (it) {
+ if (isObject(it) && TYPED_ARRAY in it) return it;
+ throw TypeError(it + ' is not a typed array!');
+ };
+
+ var allocate = function (C, length) {
+ if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {
+ throw TypeError('It is not a typed array constructor!');
+ } return new C(length);
+ };
+
+ var speciesFromList = function (O, list) {
+ return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
+ };
+
+ var fromList = function (C, list) {
+ var index = 0;
+ var length = list.length;
+ var result = allocate(C, length);
+ while (length > index) result[index] = list[index++];
+ return result;
+ };
+
+ var addGetter = function (it, key, internal) {
+ dP(it, key, { get: function () { return this._d[internal]; } });
+ };
+
+ var $from = function from(source /* , mapfn, thisArg */) {
+ var O = toObject(source);
+ var aLen = arguments.length;
+ var mapfn = aLen > 1 ? arguments[1] : undefined;
+ var mapping = mapfn !== undefined;
+ var iterFn = getIterFn(O);
+ var i, length, values, result, step, iterator;
+ if (iterFn != undefined && !isArrayIter(iterFn)) {
+ for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) {
+ values.push(step.value);
+ } O = values;
+ }
+ if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);
+ for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) {
+ result[i] = mapping ? mapfn(O[i], i) : O[i];
+ }
+ return result;
+ };
+
+ var $of = function of(/* ...items */) {
+ var index = 0;
+ var length = arguments.length;
+ var result = allocate(this, length);
+ while (length > index) result[index] = arguments[index++];
+ return result;
+ };
+
+ // iOS Safari 6.x fails here
+ var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); });
+
+ var $toLocaleString = function toLocaleString() {
+ return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);
+ };
+
+ var proto = {
+ copyWithin: function copyWithin(target, start /* , end */) {
+ return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
+ },
+ every: function every(callbackfn /* , thisArg */) {
+ return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars
+ return arrayFill.apply(validate(this), arguments);
+ },
+ filter: function filter(callbackfn /* , thisArg */) {
+ return speciesFromList(this, arrayFilter(validate(this), callbackfn,
+ arguments.length > 1 ? arguments[1] : undefined));
+ },
+ find: function find(predicate /* , thisArg */) {
+ return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ findIndex: function findIndex(predicate /* , thisArg */) {
+ return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ forEach: function forEach(callbackfn /* , thisArg */) {
+ arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ indexOf: function indexOf(searchElement /* , fromIndex */) {
+ return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ includes: function includes(searchElement /* , fromIndex */) {
+ return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ join: function join(separator) { // eslint-disable-line no-unused-vars
+ return arrayJoin.apply(validate(this), arguments);
+ },
+ lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars
+ return arrayLastIndexOf.apply(validate(this), arguments);
+ },
+ map: function map(mapfn /* , thisArg */) {
+ return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars
+ return arrayReduce.apply(validate(this), arguments);
+ },
+ reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars
+ return arrayReduceRight.apply(validate(this), arguments);
+ },
+ reverse: function reverse() {
+ var that = this;
+ var length = validate(that).length;
+ var middle = Math.floor(length / 2);
+ var index = 0;
+ var value;
+ while (index < middle) {
+ value = that[index];
+ that[index++] = that[--length];
+ that[length] = value;
+ } return that;
+ },
+ some: function some(callbackfn /* , thisArg */) {
+ return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+ },
+ sort: function sort(comparefn) {
+ return arraySort.call(validate(this), comparefn);
+ },
+ subarray: function subarray(begin, end) {
+ var O = validate(this);
+ var length = O.length;
+ var $begin = toAbsoluteIndex(begin, length);
+ return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
+ O.buffer,
+ O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
+ toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)
+ );
+ }
+ };
+
+ var $slice = function slice(start, end) {
+ return speciesFromList(this, arraySlice.call(validate(this), start, end));
+ };
+
+ var $set = function set(arrayLike /* , offset */) {
+ validate(this);
+ var offset = toOffset(arguments[1], 1);
+ var length = this.length;
+ var src = toObject(arrayLike);
+ var len = toLength(src.length);
+ var index = 0;
+ if (len + offset > length) throw RangeError(WRONG_LENGTH);
+ while (index < len) this[offset + index] = src[index++];
+ };
+
+ var $iterators = {
+ entries: function entries() {
+ return arrayEntries.call(validate(this));
+ },
+ keys: function keys() {
+ return arrayKeys.call(validate(this));
+ },
+ values: function values() {
+ return arrayValues.call(validate(this));
+ }
+ };
+
+ var isTAIndex = function (target, key) {
+ return isObject(target)
+ && target[TYPED_ARRAY]
+ && typeof key != 'symbol'
+ && key in target
+ && String(+key) == String(key);
+ };
+ var $getDesc = function getOwnPropertyDescriptor(target, key) {
+ return isTAIndex(target, key = toPrimitive(key, true))
+ ? propertyDesc(2, target[key])
+ : gOPD(target, key);
+ };
+ var $setDesc = function defineProperty(target, key, desc) {
+ if (isTAIndex(target, key = toPrimitive(key, true))
+ && isObject(desc)
+ && has(desc, 'value')
+ && !has(desc, 'get')
+ && !has(desc, 'set')
+ // TODO: add validation descriptor w/o calling accessors
+ && !desc.configurable
+ && (!has(desc, 'writable') || desc.writable)
+ && (!has(desc, 'enumerable') || desc.enumerable)
+ ) {
+ target[key] = desc.value;
+ return target;
+ } return dP(target, key, desc);
+ };
+
+ if (!ALL_CONSTRUCTORS) {
+ $GOPD.f = $getDesc;
+ $DP.f = $setDesc;
+ }
+
+ $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {
+ getOwnPropertyDescriptor: $getDesc,
+ defineProperty: $setDesc
+ });
+
+ if (fails(function () { arrayToString.call({}); })) {
+ arrayToString = arrayToLocaleString = function toString() {
+ return arrayJoin.call(this);
+ };
+ }
+
+ var $TypedArrayPrototype$ = redefineAll({}, proto);
+ redefineAll($TypedArrayPrototype$, $iterators);
+ hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
+ redefineAll($TypedArrayPrototype$, {
+ slice: $slice,
+ set: $set,
+ constructor: function () { /* noop */ },
+ toString: arrayToString,
+ toLocaleString: $toLocaleString
+ });
+ addGetter($TypedArrayPrototype$, 'buffer', 'b');
+ addGetter($TypedArrayPrototype$, 'byteOffset', 'o');
+ addGetter($TypedArrayPrototype$, 'byteLength', 'l');
+ addGetter($TypedArrayPrototype$, 'length', 'e');
+ dP($TypedArrayPrototype$, TAG, {
+ get: function () { return this[TYPED_ARRAY]; }
+ });
+
+ // eslint-disable-next-line max-statements
+ module.exports = function (KEY, BYTES, wrapper, CLAMPED) {
+ CLAMPED = !!CLAMPED;
+ var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array';
+ var GETTER = 'get' + KEY;
+ var SETTER = 'set' + KEY;
+ var TypedArray = global[NAME];
+ var Base = TypedArray || {};
+ var TAC = TypedArray && getPrototypeOf(TypedArray);
+ var FORCED = !TypedArray || !$typed.ABV;
+ var O = {};
+ var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];
+ var getter = function (that, index) {
+ var data = that._d;
+ return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
+ };
+ var setter = function (that, index, value) {
+ var data = that._d;
+ if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;
+ data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
+ };
+ var addElement = function (that, index) {
+ dP(that, index, {
+ get: function () {
+ return getter(this, index);
+ },
+ set: function (value) {
+ return setter(this, index, value);
+ },
+ enumerable: true
+ });
+ };
+ if (FORCED) {
+ TypedArray = wrapper(function (that, data, $offset, $length) {
+ anInstance(that, TypedArray, NAME, '_d');
+ var index = 0;
+ var offset = 0;
+ var buffer, byteLength, length, klass;
+ if (!isObject(data)) {
+ length = toIndex(data);
+ byteLength = length * BYTES;
+ buffer = new $ArrayBuffer(byteLength);
+ } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {
+ buffer = data;
+ offset = toOffset($offset, BYTES);
+ var $len = data.byteLength;
+ if ($length === undefined) {
+ if ($len % BYTES) throw RangeError(WRONG_LENGTH);
+ byteLength = $len - offset;
+ if (byteLength < 0) throw RangeError(WRONG_LENGTH);
+ } else {
+ byteLength = toLength($length) * BYTES;
+ if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);
+ }
+ length = byteLength / BYTES;
+ } else if (TYPED_ARRAY in data) {
+ return fromList(TypedArray, data);
+ } else {
+ return $from.call(TypedArray, data);
+ }
+ hide(that, '_d', {
+ b: buffer,
+ o: offset,
+ l: byteLength,
+ e: length,
+ v: new $DataView(buffer)
+ });
+ while (index < length) addElement(that, index++);
+ });
+ TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);
+ hide(TypedArrayPrototype, 'constructor', TypedArray);
+ } else if (!fails(function () {
+ TypedArray(1);
+ }) || !fails(function () {
+ new TypedArray(-1); // eslint-disable-line no-new
+ }) || !$iterDetect(function (iter) {
+ new TypedArray(); // eslint-disable-line no-new
+ new TypedArray(null); // eslint-disable-line no-new
+ new TypedArray(1.5); // eslint-disable-line no-new
+ new TypedArray(iter); // eslint-disable-line no-new
+ }, true)) {
+ TypedArray = wrapper(function (that, data, $offset, $length) {
+ anInstance(that, TypedArray, NAME);
+ var klass;
+ // `ws` module bug, temporarily remove validation length for Uint8Array
+ // https://github.com/websockets/ws/pull/645
+ if (!isObject(data)) return new Base(toIndex(data));
+ if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {
+ return $length !== undefined
+ ? new Base(data, toOffset($offset, BYTES), $length)
+ : $offset !== undefined
+ ? new Base(data, toOffset($offset, BYTES))
+ : new Base(data);
+ }
+ if (TYPED_ARRAY in data) return fromList(TypedArray, data);
+ return $from.call(TypedArray, data);
+ });
+ arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) {
+ if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);
+ });
+ TypedArray[PROTOTYPE] = TypedArrayPrototype;
+ if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;
+ }
+ var $nativeIterator = TypedArrayPrototype[ITERATOR];
+ var CORRECT_ITER_NAME = !!$nativeIterator
+ && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined);
+ var $iterator = $iterators.values;
+ hide(TypedArray, TYPED_CONSTRUCTOR, true);
+ hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
+ hide(TypedArrayPrototype, VIEW, true);
+ hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);
+
+ if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) {
+ dP(TypedArrayPrototype, TAG, {
+ get: function () { return NAME; }
+ });
+ }
+
+ O[NAME] = TypedArray;
+
+ $export($export.G + $export.W + $export.F * (TypedArray != Base), O);
+
+ $export($export.S, NAME, {
+ BYTES_PER_ELEMENT: BYTES
+ });
+
+ $export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, {
+ from: $from,
+ of: $of
+ });
+
+ if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);
+
+ $export($export.P, NAME, proto);
+
+ setSpecies(NAME);
+
+ $export($export.P + $export.F * FORCED_SET, NAME, { set: $set });
+
+ $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);
+
+ if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString;
+
+ $export($export.P + $export.F * fails(function () {
+ new TypedArray(1).slice();
+ }), NAME, { slice: $slice });
+
+ $export($export.P + $export.F * (fails(function () {
+ return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString();
+ }) || !fails(function () {
+ TypedArrayPrototype.toLocaleString.call([1, 2]);
+ })), NAME, { toLocaleString: $toLocaleString });
+
+ Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
+ if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator);
+ };
+} else module.exports = function () { /* empty */ };
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-buffer.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-buffer.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js");
+var $typed = __webpack_require__(/*! ./_typed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var toIndex = __webpack_require__(/*! ./_to-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-index.js");
+var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js").f;
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var arrayFill = __webpack_require__(/*! ./_array-fill */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-fill.js");
+var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js");
+var ARRAY_BUFFER = 'ArrayBuffer';
+var DATA_VIEW = 'DataView';
+var PROTOTYPE = 'prototype';
+var WRONG_LENGTH = 'Wrong length!';
+var WRONG_INDEX = 'Wrong index!';
+var $ArrayBuffer = global[ARRAY_BUFFER];
+var $DataView = global[DATA_VIEW];
+var Math = global.Math;
+var RangeError = global.RangeError;
+// eslint-disable-next-line no-shadow-restricted-names
+var Infinity = global.Infinity;
+var BaseBuffer = $ArrayBuffer;
+var abs = Math.abs;
+var pow = Math.pow;
+var floor = Math.floor;
+var log = Math.log;
+var LN2 = Math.LN2;
+var BUFFER = 'buffer';
+var BYTE_LENGTH = 'byteLength';
+var BYTE_OFFSET = 'byteOffset';
+var $BUFFER = DESCRIPTORS ? '_b' : BUFFER;
+var $LENGTH = DESCRIPTORS ? '_l' : BYTE_LENGTH;
+var $OFFSET = DESCRIPTORS ? '_o' : BYTE_OFFSET;
+
+// IEEE754 conversions based on https://github.com/feross/ieee754
+function packIEEE754(value, mLen, nBytes) {
+ var buffer = new Array(nBytes);
+ var eLen = nBytes * 8 - mLen - 1;
+ var eMax = (1 << eLen) - 1;
+ var eBias = eMax >> 1;
+ var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0;
+ var i = 0;
+ var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+ var e, m, c;
+ value = abs(value);
+ // eslint-disable-next-line no-self-compare
+ if (value != value || value === Infinity) {
+ // eslint-disable-next-line no-self-compare
+ m = value != value ? 1 : 0;
+ e = eMax;
+ } else {
+ e = floor(log(value) / LN2);
+ if (value * (c = pow(2, -e)) < 1) {
+ e--;
+ c *= 2;
+ }
+ if (e + eBias >= 1) {
+ value += rt / c;
+ } else {
+ value += rt * pow(2, 1 - eBias);
+ }
+ if (value * c >= 2) {
+ e++;
+ c /= 2;
+ }
+ if (e + eBias >= eMax) {
+ m = 0;
+ e = eMax;
+ } else if (e + eBias >= 1) {
+ m = (value * c - 1) * pow(2, mLen);
+ e = e + eBias;
+ } else {
+ m = value * pow(2, eBias - 1) * pow(2, mLen);
+ e = 0;
+ }
+ }
+ for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8);
+ e = e << mLen | m;
+ eLen += mLen;
+ for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8);
+ buffer[--i] |= s * 128;
+ return buffer;
+}
+function unpackIEEE754(buffer, mLen, nBytes) {
+ var eLen = nBytes * 8 - mLen - 1;
+ var eMax = (1 << eLen) - 1;
+ var eBias = eMax >> 1;
+ var nBits = eLen - 7;
+ var i = nBytes - 1;
+ var s = buffer[i--];
+ var e = s & 127;
+ var m;
+ s >>= 7;
+ for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8);
+ m = e & (1 << -nBits) - 1;
+ e >>= -nBits;
+ nBits += mLen;
+ for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8);
+ if (e === 0) {
+ e = 1 - eBias;
+ } else if (e === eMax) {
+ return m ? NaN : s ? -Infinity : Infinity;
+ } else {
+ m = m + pow(2, mLen);
+ e = e - eBias;
+ } return (s ? -1 : 1) * m * pow(2, e - mLen);
+}
+
+function unpackI32(bytes) {
+ return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
+}
+function packI8(it) {
+ return [it & 0xff];
+}
+function packI16(it) {
+ return [it & 0xff, it >> 8 & 0xff];
+}
+function packI32(it) {
+ return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff];
+}
+function packF64(it) {
+ return packIEEE754(it, 52, 8);
+}
+function packF32(it) {
+ return packIEEE754(it, 23, 4);
+}
+
+function addGetter(C, key, internal) {
+ dP(C[PROTOTYPE], key, { get: function () { return this[internal]; } });
+}
+
+function get(view, bytes, index, isLittleEndian) {
+ var numIndex = +index;
+ var intIndex = toIndex(numIndex);
+ if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
+ var store = view[$BUFFER]._b;
+ var start = intIndex + view[$OFFSET];
+ var pack = store.slice(start, start + bytes);
+ return isLittleEndian ? pack : pack.reverse();
+}
+function set(view, bytes, index, conversion, value, isLittleEndian) {
+ var numIndex = +index;
+ var intIndex = toIndex(numIndex);
+ if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
+ var store = view[$BUFFER]._b;
+ var start = intIndex + view[$OFFSET];
+ var pack = conversion(+value);
+ for (var i = 0; i < bytes; i++) store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];
+}
+
+if (!$typed.ABV) {
+ $ArrayBuffer = function ArrayBuffer(length) {
+ anInstance(this, $ArrayBuffer, ARRAY_BUFFER);
+ var byteLength = toIndex(length);
+ this._b = arrayFill.call(new Array(byteLength), 0);
+ this[$LENGTH] = byteLength;
+ };
+
+ $DataView = function DataView(buffer, byteOffset, byteLength) {
+ anInstance(this, $DataView, DATA_VIEW);
+ anInstance(buffer, $ArrayBuffer, DATA_VIEW);
+ var bufferLength = buffer[$LENGTH];
+ var offset = toInteger(byteOffset);
+ if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset!');
+ byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
+ if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
+ this[$BUFFER] = buffer;
+ this[$OFFSET] = offset;
+ this[$LENGTH] = byteLength;
+ };
+
+ if (DESCRIPTORS) {
+ addGetter($ArrayBuffer, BYTE_LENGTH, '_l');
+ addGetter($DataView, BUFFER, '_b');
+ addGetter($DataView, BYTE_LENGTH, '_l');
+ addGetter($DataView, BYTE_OFFSET, '_o');
+ }
+
+ redefineAll($DataView[PROTOTYPE], {
+ getInt8: function getInt8(byteOffset) {
+ return get(this, 1, byteOffset)[0] << 24 >> 24;
+ },
+ getUint8: function getUint8(byteOffset) {
+ return get(this, 1, byteOffset)[0];
+ },
+ getInt16: function getInt16(byteOffset /* , littleEndian */) {
+ var bytes = get(this, 2, byteOffset, arguments[1]);
+ return (bytes[1] << 8 | bytes[0]) << 16 >> 16;
+ },
+ getUint16: function getUint16(byteOffset /* , littleEndian */) {
+ var bytes = get(this, 2, byteOffset, arguments[1]);
+ return bytes[1] << 8 | bytes[0];
+ },
+ getInt32: function getInt32(byteOffset /* , littleEndian */) {
+ return unpackI32(get(this, 4, byteOffset, arguments[1]));
+ },
+ getUint32: function getUint32(byteOffset /* , littleEndian */) {
+ return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;
+ },
+ getFloat32: function getFloat32(byteOffset /* , littleEndian */) {
+ return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);
+ },
+ getFloat64: function getFloat64(byteOffset /* , littleEndian */) {
+ return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);
+ },
+ setInt8: function setInt8(byteOffset, value) {
+ set(this, 1, byteOffset, packI8, value);
+ },
+ setUint8: function setUint8(byteOffset, value) {
+ set(this, 1, byteOffset, packI8, value);
+ },
+ setInt16: function setInt16(byteOffset, value /* , littleEndian */) {
+ set(this, 2, byteOffset, packI16, value, arguments[2]);
+ },
+ setUint16: function setUint16(byteOffset, value /* , littleEndian */) {
+ set(this, 2, byteOffset, packI16, value, arguments[2]);
+ },
+ setInt32: function setInt32(byteOffset, value /* , littleEndian */) {
+ set(this, 4, byteOffset, packI32, value, arguments[2]);
+ },
+ setUint32: function setUint32(byteOffset, value /* , littleEndian */) {
+ set(this, 4, byteOffset, packI32, value, arguments[2]);
+ },
+ setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {
+ set(this, 4, byteOffset, packF32, value, arguments[2]);
+ },
+ setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {
+ set(this, 8, byteOffset, packF64, value, arguments[2]);
+ }
+ });
+} else {
+ if (!fails(function () {
+ $ArrayBuffer(1);
+ }) || !fails(function () {
+ new $ArrayBuffer(-1); // eslint-disable-line no-new
+ }) || fails(function () {
+ new $ArrayBuffer(); // eslint-disable-line no-new
+ new $ArrayBuffer(1.5); // eslint-disable-line no-new
+ new $ArrayBuffer(NaN); // eslint-disable-line no-new
+ return $ArrayBuffer.name != ARRAY_BUFFER;
+ })) {
+ $ArrayBuffer = function ArrayBuffer(length) {
+ anInstance(this, $ArrayBuffer);
+ return new BaseBuffer(toIndex(length));
+ };
+ var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE];
+ for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j;) {
+ if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, BaseBuffer[key]);
+ }
+ if (!LIBRARY) ArrayBufferProto.constructor = $ArrayBuffer;
+ }
+ // iOS Safari 7.x bug
+ var view = new $DataView(new $ArrayBuffer(2));
+ var $setInt8 = $DataView[PROTOTYPE].setInt8;
+ view.setInt8(0, 2147483648);
+ view.setInt8(1, 2147483649);
+ if (view.getInt8(0) || !view.getInt8(1)) redefineAll($DataView[PROTOTYPE], {
+ setInt8: function setInt8(byteOffset, value) {
+ $setInt8.call(this, byteOffset, value << 24 >> 24);
+ },
+ setUint8: function setUint8(byteOffset, value) {
+ $setInt8.call(this, byteOffset, value << 24 >> 24);
+ }
+ }, true);
+}
+setToStringTag($ArrayBuffer, ARRAY_BUFFER);
+setToStringTag($DataView, DATA_VIEW);
+hide($DataView[PROTOTYPE], $typed.VIEW, true);
+exports[ARRAY_BUFFER] = $ArrayBuffer;
+exports[DATA_VIEW] = $DataView;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed.js":
+/*!****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_typed.js ***!
+ \****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var uid = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js");
+var TYPED = uid('typed_array');
+var VIEW = uid('view');
+var ABV = !!(global.ArrayBuffer && global.DataView);
+var CONSTR = ABV;
+var i = 0;
+var l = 9;
+var Typed;
+
+var TypedArrayConstructors = (
+ 'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'
+).split(',');
+
+while (i < l) {
+ if (Typed = global[TypedArrayConstructors[i++]]) {
+ hide(Typed.prototype, TYPED, true);
+ hide(Typed.prototype, VIEW, true);
+ } else CONSTR = false;
+}
+
+module.exports = {
+ ABV: ABV,
+ CONSTR: CONSTR,
+ TYPED: TYPED,
+ VIEW: VIEW
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var id = 0;
+var px = Math.random();
+module.exports = function (key) {
+ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_user-agent.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_user-agent.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var navigator = global.navigator;
+
+module.exports = navigator && navigator.userAgent || '';
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+module.exports = function (it, TYPE) {
+ if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
+ return it;
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-define.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-define.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var core = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js");
+var wksExt = __webpack_require__(/*! ./_wks-ext */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-ext.js");
+var defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+module.exports = function (name) {
+ var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
+ if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-ext.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-ext.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+exports.f = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js");
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js":
+/*!**************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var store = __webpack_require__(/*! ./_shared */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js")('wks');
+var uid = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js");
+var Symbol = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").Symbol;
+var USE_SYMBOL = typeof Symbol == 'function';
+
+var $exports = module.exports = function (name) {
+ return store[name] || (store[name] =
+ USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
+};
+
+$exports.store = store;
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/core.get-iterator-method.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/core.get-iterator-method.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var classof = __webpack_require__(/*! ./_classof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js");
+var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('iterator');
+var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js");
+module.exports = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js").getIteratorMethod = function (it) {
+ if (it != undefined) return it[ITERATOR]
+ || it['@@iterator']
+ || Iterators[classof(it)];
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/core.regexp.escape.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/core.regexp.escape.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/benjamingr/RexExp.escape
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $re = __webpack_require__(/*! ./_replacer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_replacer.js")(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+
+$export($export.S, 'RegExp', { escape: function escape(it) { return $re(it); } });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.copy-within.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.copy-within.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.P, 'Array', { copyWithin: __webpack_require__(/*! ./_array-copy-within */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-copy-within.js") });
+
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")('copyWithin');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.every.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.every.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $every = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(4);
+
+$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].every, true), 'Array', {
+ // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])
+ every: function every(callbackfn /* , thisArg */) {
+ return $every(this, callbackfn, arguments[1]);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.fill.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.fill.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.P, 'Array', { fill: __webpack_require__(/*! ./_array-fill */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-fill.js") });
+
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")('fill');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.filter.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.filter.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $filter = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(2);
+
+$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].filter, true), 'Array', {
+ // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])
+ filter: function filter(callbackfn /* , thisArg */) {
+ return $filter(this, callbackfn, arguments[1]);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.find-index.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.find-index.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $find = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(6);
+var KEY = 'findIndex';
+var forced = true;
+// Shouldn't skip holes
+if (KEY in []) Array(1)[KEY](function () { forced = false; });
+$export($export.P + $export.F * forced, 'Array', {
+ findIndex: function findIndex(callbackfn /* , that = undefined */) {
+ return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")(KEY);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.find.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.find.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $find = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(5);
+var KEY = 'find';
+var forced = true;
+// Shouldn't skip holes
+if (KEY in []) Array(1)[KEY](function () { forced = false; });
+$export($export.P + $export.F * forced, 'Array', {
+ find: function find(callbackfn /* , that = undefined */) {
+ return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")(KEY);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.for-each.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.for-each.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $forEach = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(0);
+var STRICT = __webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].forEach, true);
+
+$export($export.P + $export.F * !STRICT, 'Array', {
+ // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])
+ forEach: function forEach(callbackfn /* , thisArg */) {
+ return $forEach(this, callbackfn, arguments[1]);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.from.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.from.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var call = __webpack_require__(/*! ./_iter-call */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-call.js");
+var isArrayIter = __webpack_require__(/*! ./_is-array-iter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array-iter.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var createProperty = __webpack_require__(/*! ./_create-property */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_create-property.js");
+var getIterFn = __webpack_require__(/*! ./core.get-iterator-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/core.get-iterator-method.js");
+
+$export($export.S + $export.F * !__webpack_require__(/*! ./_iter-detect */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-detect.js")(function (iter) { Array.from(iter); }), 'Array', {
+ // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
+ from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+ var O = toObject(arrayLike);
+ var C = typeof this == 'function' ? this : Array;
+ var aLen = arguments.length;
+ var mapfn = aLen > 1 ? arguments[1] : undefined;
+ var mapping = mapfn !== undefined;
+ var index = 0;
+ var iterFn = getIterFn(O);
+ var length, result, step, iterator;
+ if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
+ // if object isn't iterable or it's array with default iterator - use simple case
+ if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
+ for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
+ createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
+ }
+ } else {
+ length = toLength(O.length);
+ for (result = new C(length); length > index; index++) {
+ createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
+ }
+ }
+ result.length = index;
+ return result;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.index-of.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.index-of.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $indexOf = __webpack_require__(/*! ./_array-includes */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-includes.js")(false);
+var $native = [].indexOf;
+var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;
+
+$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")($native)), 'Array', {
+ // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])
+ indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {
+ return NEGATIVE_ZERO
+ // convert -0 to +0
+ ? $native.apply(this, arguments) || 0
+ : $indexOf(this, searchElement, arguments[1]);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.is-array.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.is-array.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 22.1.2.2 / 15.4.3.2 Array.isArray(arg)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Array', { isArray: __webpack_require__(/*! ./_is-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.iterator.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.iterator.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var addToUnscopables = __webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js");
+var step = __webpack_require__(/*! ./_iter-step */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-step.js");
+var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+
+// 22.1.3.4 Array.prototype.entries()
+// 22.1.3.13 Array.prototype.keys()
+// 22.1.3.29 Array.prototype.values()
+// 22.1.3.30 Array.prototype[@@iterator]()
+module.exports = __webpack_require__(/*! ./_iter-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-define.js")(Array, 'Array', function (iterated, kind) {
+ this._t = toIObject(iterated); // target
+ this._i = 0; // next index
+ this._k = kind; // kind
+// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+}, function () {
+ var O = this._t;
+ var kind = this._k;
+ var index = this._i++;
+ if (!O || index >= O.length) {
+ this._t = undefined;
+ return step(1);
+ }
+ if (kind == 'keys') return step(0, index);
+ if (kind == 'values') return step(0, O[index]);
+ return step(0, [index, O[index]]);
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+Iterators.Arguments = Iterators.Array;
+
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.join.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.join.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 22.1.3.13 Array.prototype.join(separator)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var arrayJoin = [].join;
+
+// fallback for not array-like strings
+$export($export.P + $export.F * (__webpack_require__(/*! ./_iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iobject.js") != Object || !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")(arrayJoin)), 'Array', {
+ join: function join(separator) {
+ return arrayJoin.call(toIObject(this), separator === undefined ? ',' : separator);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.last-index-of.js":
+/*!*********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.last-index-of.js ***!
+ \*********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var $native = [].lastIndexOf;
+var NEGATIVE_ZERO = !!$native && 1 / [1].lastIndexOf(1, -0) < 0;
+
+$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")($native)), 'Array', {
+ // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])
+ lastIndexOf: function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
+ // convert -0 to +0
+ if (NEGATIVE_ZERO) return $native.apply(this, arguments) || 0;
+ var O = toIObject(this);
+ var length = toLength(O.length);
+ var index = length - 1;
+ if (arguments.length > 1) index = Math.min(index, toInteger(arguments[1]));
+ if (index < 0) index = length + index;
+ for (;index >= 0; index--) if (index in O) if (O[index] === searchElement) return index || 0;
+ return -1;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.map.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.map.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $map = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(1);
+
+$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].map, true), 'Array', {
+ // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])
+ map: function map(callbackfn /* , thisArg */) {
+ return $map(this, callbackfn, arguments[1]);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.of.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.of.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var createProperty = __webpack_require__(/*! ./_create-property */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_create-property.js");
+
+// WebKit Array.of isn't generic
+$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ function F() { /* empty */ }
+ return !(Array.of.call(F) instanceof F);
+}), 'Array', {
+ // 22.1.2.3 Array.of( ...items)
+ of: function of(/* ...args */) {
+ var index = 0;
+ var aLen = arguments.length;
+ var result = new (typeof this == 'function' ? this : Array)(aLen);
+ while (aLen > index) createProperty(result, index, arguments[index++]);
+ result.length = aLen;
+ return result;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.reduce-right.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.reduce-right.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $reduce = __webpack_require__(/*! ./_array-reduce */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-reduce.js");
+
+$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].reduceRight, true), 'Array', {
+ // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])
+ reduceRight: function reduceRight(callbackfn /* , initialValue */) {
+ return $reduce(this, callbackfn, arguments.length, arguments[1], true);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.reduce.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.reduce.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $reduce = __webpack_require__(/*! ./_array-reduce */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-reduce.js");
+
+$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].reduce, true), 'Array', {
+ // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])
+ reduce: function reduce(callbackfn /* , initialValue */) {
+ return $reduce(this, callbackfn, arguments.length, arguments[1], false);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.slice.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.slice.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var html = __webpack_require__(/*! ./_html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_html.js");
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var arraySlice = [].slice;
+
+// fallback for not array-like ES3 strings and DOM objects
+$export($export.P + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ if (html) arraySlice.call(html);
+}), 'Array', {
+ slice: function slice(begin, end) {
+ var len = toLength(this.length);
+ var klass = cof(this);
+ end = end === undefined ? len : end;
+ if (klass == 'Array') return arraySlice.call(this, begin, end);
+ var start = toAbsoluteIndex(begin, len);
+ var upTo = toAbsoluteIndex(end, len);
+ var size = toLength(upTo - start);
+ var cloned = new Array(size);
+ var i = 0;
+ for (; i < size; i++) cloned[i] = klass == 'String'
+ ? this.charAt(start + i)
+ : this[start + i];
+ return cloned;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.some.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.some.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $some = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(3);
+
+$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")([].some, true), 'Array', {
+ // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])
+ some: function some(callbackfn /* , thisArg */) {
+ return $some(this, callbackfn, arguments[1]);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.sort.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.sort.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var $sort = [].sort;
+var test = [1, 2, 3];
+
+$export($export.P + $export.F * (fails(function () {
+ // IE8-
+ test.sort(undefined);
+}) || !fails(function () {
+ // V8 bug
+ test.sort(null);
+ // Old WebKit
+}) || !__webpack_require__(/*! ./_strict-method */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_strict-method.js")($sort)), 'Array', {
+ // 22.1.3.25 Array.prototype.sort(comparefn)
+ sort: function sort(comparefn) {
+ return comparefn === undefined
+ ? $sort.call(toObject(this))
+ : $sort.call(toObject(this), aFunction(comparefn));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.species.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.species.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js")('Array');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.now.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.now.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.3.3.1 / 15.9.4.4 Date.now()
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Date', { now: function () { return new Date().getTime(); } });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-iso-string.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-iso-string.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toISOString = __webpack_require__(/*! ./_date-to-iso-string */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_date-to-iso-string.js");
+
+// PhantomJS / old WebKit has a broken implementations
+$export($export.P + $export.F * (Date.prototype.toISOString !== toISOString), 'Date', {
+ toISOString: toISOString
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-json.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-json.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+
+$export($export.P + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return new Date(NaN).toJSON() !== null
+ || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1;
+}), 'Date', {
+ // eslint-disable-next-line no-unused-vars
+ toJSON: function toJSON(key) {
+ var O = toObject(this);
+ var pv = toPrimitive(O);
+ return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-primitive.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-primitive.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var TO_PRIMITIVE = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('toPrimitive');
+var proto = Date.prototype;
+
+if (!(TO_PRIMITIVE in proto)) __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js")(proto, TO_PRIMITIVE, __webpack_require__(/*! ./_date-to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_date-to-primitive.js"));
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-string.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-string.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var DateProto = Date.prototype;
+var INVALID_DATE = 'Invalid Date';
+var TO_STRING = 'toString';
+var $toString = DateProto[TO_STRING];
+var getTime = DateProto.getTime;
+if (new Date(NaN) + '' != INVALID_DATE) {
+ __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js")(DateProto, TO_STRING, function toString() {
+ var value = getTime.call(this);
+ // eslint-disable-next-line no-self-compare
+ return value === value ? $toString.call(this) : INVALID_DATE;
+ });
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.bind.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.bind.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.P, 'Function', { bind: __webpack_require__(/*! ./_bind */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_bind.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.has-instance.js":
+/*!***********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.has-instance.js ***!
+ \***********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var HAS_INSTANCE = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('hasInstance');
+var FunctionProto = Function.prototype;
+// 19.2.3.6 Function.prototype[@@hasInstance](V)
+if (!(HAS_INSTANCE in FunctionProto)) __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f(FunctionProto, HAS_INSTANCE, { value: function (O) {
+ if (typeof this != 'function' || !isObject(O)) return false;
+ if (!isObject(this.prototype)) return O instanceof this;
+ // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:
+ while (O = getPrototypeOf(O)) if (this.prototype === O) return true;
+ return false;
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.name.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.name.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var FProto = Function.prototype;
+var nameRE = /^\s*function ([^ (]*)/;
+var NAME = 'name';
+
+// 19.2.4.2 name
+NAME in FProto || __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && dP(FProto, NAME, {
+ configurable: true,
+ get: function () {
+ try {
+ return ('' + this).match(nameRE)[1];
+ } catch (e) {
+ return '';
+ }
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.map.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.map.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var strong = __webpack_require__(/*! ./_collection-strong */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-strong.js");
+var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var MAP = 'Map';
+
+// 23.1 Map Objects
+module.exports = __webpack_require__(/*! ./_collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection.js")(MAP, function (get) {
+ return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+}, {
+ // 23.1.3.6 Map.prototype.get(key)
+ get: function get(key) {
+ var entry = strong.getEntry(validate(this, MAP), key);
+ return entry && entry.v;
+ },
+ // 23.1.3.9 Map.prototype.set(key, value)
+ set: function set(key, value) {
+ return strong.def(validate(this, MAP), key === 0 ? 0 : key, value);
+ }
+}, strong, true);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.acosh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.acosh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.3 Math.acosh(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var log1p = __webpack_require__(/*! ./_math-log1p */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-log1p.js");
+var sqrt = Math.sqrt;
+var $acosh = Math.acosh;
+
+$export($export.S + $export.F * !($acosh
+ // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
+ && Math.floor($acosh(Number.MAX_VALUE)) == 710
+ // Tor Browser bug: Math.acosh(Infinity) -> NaN
+ && $acosh(Infinity) == Infinity
+), 'Math', {
+ acosh: function acosh(x) {
+ return (x = +x) < 1 ? NaN : x > 94906265.62425156
+ ? Math.log(x) + Math.LN2
+ : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.asinh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.asinh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.5 Math.asinh(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $asinh = Math.asinh;
+
+function asinh(x) {
+ return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1));
+}
+
+// Tor Browser bug: Math.asinh(0) -> -0
+$export($export.S + $export.F * !($asinh && 1 / $asinh(0) > 0), 'Math', { asinh: asinh });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.atanh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.atanh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.7 Math.atanh(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $atanh = Math.atanh;
+
+// Tor Browser bug: Math.atanh(-0) -> 0
+$export($export.S + $export.F * !($atanh && 1 / $atanh(-0) < 0), 'Math', {
+ atanh: function atanh(x) {
+ return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.cbrt.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.cbrt.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.9 Math.cbrt(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var sign = __webpack_require__(/*! ./_math-sign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-sign.js");
+
+$export($export.S, 'Math', {
+ cbrt: function cbrt(x) {
+ return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.clz32.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.clz32.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.11 Math.clz32(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ clz32: function clz32(x) {
+ return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.cosh.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.cosh.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.12 Math.cosh(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var exp = Math.exp;
+
+$export($export.S, 'Math', {
+ cosh: function cosh(x) {
+ return (exp(x = +x) + exp(-x)) / 2;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.expm1.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.expm1.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.14 Math.expm1(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $expm1 = __webpack_require__(/*! ./_math-expm1 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-expm1.js");
+
+$export($export.S + $export.F * ($expm1 != Math.expm1), 'Math', { expm1: $expm1 });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.fround.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.fround.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.16 Math.fround(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { fround: __webpack_require__(/*! ./_math-fround */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-fround.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.hypot.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.hypot.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.17 Math.hypot([value1[, value2[, … ]]])
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var abs = Math.abs;
+
+$export($export.S, 'Math', {
+ hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars
+ var sum = 0;
+ var i = 0;
+ var aLen = arguments.length;
+ var larg = 0;
+ var arg, div;
+ while (i < aLen) {
+ arg = abs(arguments[i++]);
+ if (larg < arg) {
+ div = larg / arg;
+ sum = sum * div * div + 1;
+ larg = arg;
+ } else if (arg > 0) {
+ div = arg / larg;
+ sum += div * div;
+ } else sum += arg;
+ }
+ return larg === Infinity ? Infinity : larg * Math.sqrt(sum);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.imul.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.imul.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.18 Math.imul(x, y)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $imul = Math.imul;
+
+// some WebKit versions fails with big numbers, some has wrong arity
+$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return $imul(0xffffffff, 5) != -5 || $imul.length != 2;
+}), 'Math', {
+ imul: function imul(x, y) {
+ var UINT16 = 0xffff;
+ var xn = +x;
+ var yn = +y;
+ var xl = UINT16 & xn;
+ var yl = UINT16 & yn;
+ return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log10.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log10.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.21 Math.log10(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ log10: function log10(x) {
+ return Math.log(x) * Math.LOG10E;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log1p.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log1p.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.20 Math.log1p(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { log1p: __webpack_require__(/*! ./_math-log1p */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-log1p.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log2.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log2.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.22 Math.log2(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ log2: function log2(x) {
+ return Math.log(x) / Math.LN2;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.sign.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.sign.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.28 Math.sign(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { sign: __webpack_require__(/*! ./_math-sign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-sign.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.sinh.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.sinh.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.30 Math.sinh(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var expm1 = __webpack_require__(/*! ./_math-expm1 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-expm1.js");
+var exp = Math.exp;
+
+// V8 near Chromium 38 has a problem with very small numbers
+$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return !Math.sinh(-2e-17) != -2e-17;
+}), 'Math', {
+ sinh: function sinh(x) {
+ return Math.abs(x = +x) < 1
+ ? (expm1(x) - expm1(-x)) / 2
+ : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.tanh.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.tanh.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.33 Math.tanh(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var expm1 = __webpack_require__(/*! ./_math-expm1 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-expm1.js");
+var exp = Math.exp;
+
+$export($export.S, 'Math', {
+ tanh: function tanh(x) {
+ var a = expm1(x = +x);
+ var b = expm1(-x);
+ return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.trunc.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.trunc.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.2.2.34 Math.trunc(x)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ trunc: function trunc(it) {
+ return (it > 0 ? Math.floor : Math.ceil)(it);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.constructor.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.constructor.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+var inheritIfRequired = __webpack_require__(/*! ./_inherit-if-required */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_inherit-if-required.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js").f;
+var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js").f;
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var $trim = __webpack_require__(/*! ./_string-trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js").trim;
+var NUMBER = 'Number';
+var $Number = global[NUMBER];
+var Base = $Number;
+var proto = $Number.prototype;
+// Opera ~12 has broken Object#toString
+var BROKEN_COF = cof(__webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js")(proto)) == NUMBER;
+var TRIM = 'trim' in String.prototype;
+
+// 7.1.3 ToNumber(argument)
+var toNumber = function (argument) {
+ var it = toPrimitive(argument, false);
+ if (typeof it == 'string' && it.length > 2) {
+ it = TRIM ? it.trim() : $trim(it, 3);
+ var first = it.charCodeAt(0);
+ var third, radix, maxCode;
+ if (first === 43 || first === 45) {
+ third = it.charCodeAt(2);
+ if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
+ } else if (first === 48) {
+ switch (it.charCodeAt(1)) {
+ case 66: case 98: radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i
+ case 79: case 111: radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i
+ default: return +it;
+ }
+ for (var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++) {
+ code = digits.charCodeAt(i);
+ // parseInt parses a string to a first unavailable symbol
+ // but ToNumber should return NaN if a string contains unavailable symbols
+ if (code < 48 || code > maxCode) return NaN;
+ } return parseInt(digits, radix);
+ }
+ } return +it;
+};
+
+if (!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')) {
+ $Number = function Number(value) {
+ var it = arguments.length < 1 ? 0 : value;
+ var that = this;
+ return that instanceof $Number
+ // check on 1..constructor(foo) case
+ && (BROKEN_COF ? fails(function () { proto.valueOf.call(that); }) : cof(that) != NUMBER)
+ ? inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it);
+ };
+ for (var keys = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") ? gOPN(Base) : (
+ // ES3:
+ 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
+ // ES6 (in case, if modules with ES6 Number statics required before):
+ 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
+ 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
+ ).split(','), j = 0, key; keys.length > j; j++) {
+ if (has(Base, key = keys[j]) && !has($Number, key)) {
+ dP($Number, key, gOPD(Base, key));
+ }
+ }
+ $Number.prototype = proto;
+ proto.constructor = $Number;
+ __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js")(global, NUMBER, $Number);
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.epsilon.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.epsilon.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.1 Number.EPSILON
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Number', { EPSILON: Math.pow(2, -52) });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-finite.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-finite.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.2 Number.isFinite(number)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var _isFinite = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").isFinite;
+
+$export($export.S, 'Number', {
+ isFinite: function isFinite(it) {
+ return typeof it == 'number' && _isFinite(it);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-integer.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-integer.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.3 Number.isInteger(number)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Number', { isInteger: __webpack_require__(/*! ./_is-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-integer.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-nan.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-nan.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.4 Number.isNaN(number)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Number', {
+ isNaN: function isNaN(number) {
+ // eslint-disable-next-line no-self-compare
+ return number != number;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-safe-integer.js":
+/*!************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-safe-integer.js ***!
+ \************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.5 Number.isSafeInteger(number)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var isInteger = __webpack_require__(/*! ./_is-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-integer.js");
+var abs = Math.abs;
+
+$export($export.S, 'Number', {
+ isSafeInteger: function isSafeInteger(number) {
+ return isInteger(number) && abs(number) <= 0x1fffffffffffff;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.max-safe-integer.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.max-safe-integer.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.6 Number.MAX_SAFE_INTEGER
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Number', { MAX_SAFE_INTEGER: 0x1fffffffffffff });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.min-safe-integer.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.min-safe-integer.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 20.1.2.10 Number.MIN_SAFE_INTEGER
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Number', { MIN_SAFE_INTEGER: -0x1fffffffffffff });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.parse-float.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.parse-float.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $parseFloat = __webpack_require__(/*! ./_parse-float */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-float.js");
+// 20.1.2.12 Number.parseFloat(string)
+$export($export.S + $export.F * (Number.parseFloat != $parseFloat), 'Number', { parseFloat: $parseFloat });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.parse-int.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.parse-int.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $parseInt = __webpack_require__(/*! ./_parse-int */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-int.js");
+// 20.1.2.13 Number.parseInt(string, radix)
+$export($export.S + $export.F * (Number.parseInt != $parseInt), 'Number', { parseInt: $parseInt });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.to-fixed.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.to-fixed.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var aNumberValue = __webpack_require__(/*! ./_a-number-value */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-number-value.js");
+var repeat = __webpack_require__(/*! ./_string-repeat */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-repeat.js");
+var $toFixed = 1.0.toFixed;
+var floor = Math.floor;
+var data = [0, 0, 0, 0, 0, 0];
+var ERROR = 'Number.toFixed: incorrect invocation!';
+var ZERO = '0';
+
+var multiply = function (n, c) {
+ var i = -1;
+ var c2 = c;
+ while (++i < 6) {
+ c2 += n * data[i];
+ data[i] = c2 % 1e7;
+ c2 = floor(c2 / 1e7);
+ }
+};
+var divide = function (n) {
+ var i = 6;
+ var c = 0;
+ while (--i >= 0) {
+ c += data[i];
+ data[i] = floor(c / n);
+ c = (c % n) * 1e7;
+ }
+};
+var numToString = function () {
+ var i = 6;
+ var s = '';
+ while (--i >= 0) {
+ if (s !== '' || i === 0 || data[i] !== 0) {
+ var t = String(data[i]);
+ s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t;
+ }
+ } return s;
+};
+var pow = function (x, n, acc) {
+ return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);
+};
+var log = function (x) {
+ var n = 0;
+ var x2 = x;
+ while (x2 >= 4096) {
+ n += 12;
+ x2 /= 4096;
+ }
+ while (x2 >= 2) {
+ n += 1;
+ x2 /= 2;
+ } return n;
+};
+
+$export($export.P + $export.F * (!!$toFixed && (
+ 0.00008.toFixed(3) !== '0.000' ||
+ 0.9.toFixed(0) !== '1' ||
+ 1.255.toFixed(2) !== '1.25' ||
+ 1000000000000000128.0.toFixed(0) !== '1000000000000000128'
+) || !__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ // V8 ~ Android 4.3-
+ $toFixed.call({});
+})), 'Number', {
+ toFixed: function toFixed(fractionDigits) {
+ var x = aNumberValue(this, ERROR);
+ var f = toInteger(fractionDigits);
+ var s = '';
+ var m = ZERO;
+ var e, z, j, k;
+ if (f < 0 || f > 20) throw RangeError(ERROR);
+ // eslint-disable-next-line no-self-compare
+ if (x != x) return 'NaN';
+ if (x <= -1e21 || x >= 1e21) return String(x);
+ if (x < 0) {
+ s = '-';
+ x = -x;
+ }
+ if (x > 1e-21) {
+ e = log(x * pow(2, 69, 1)) - 69;
+ z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1);
+ z *= 0x10000000000000;
+ e = 52 - e;
+ if (e > 0) {
+ multiply(0, z);
+ j = f;
+ while (j >= 7) {
+ multiply(1e7, 0);
+ j -= 7;
+ }
+ multiply(pow(10, j, 1), 0);
+ j = e - 1;
+ while (j >= 23) {
+ divide(1 << 23);
+ j -= 23;
+ }
+ divide(1 << j);
+ multiply(1, 1);
+ divide(2);
+ m = numToString();
+ } else {
+ multiply(0, z);
+ multiply(1 << -e, 0);
+ m = numToString() + repeat.call(ZERO, f);
+ }
+ }
+ if (f > 0) {
+ k = m.length;
+ m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f));
+ } else {
+ m = s + m;
+ } return m;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.to-precision.js":
+/*!*********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.to-precision.js ***!
+ \*********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var aNumberValue = __webpack_require__(/*! ./_a-number-value */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-number-value.js");
+var $toPrecision = 1.0.toPrecision;
+
+$export($export.P + $export.F * ($fails(function () {
+ // IE7-
+ return $toPrecision.call(1, undefined) !== '1';
+}) || !$fails(function () {
+ // V8 ~ Android 4.3-
+ $toPrecision.call({});
+})), 'Number', {
+ toPrecision: function toPrecision(precision) {
+ var that = aNumberValue(this, 'Number#toPrecision: incorrect invocation!');
+ return precision === undefined ? $toPrecision.call(that) : $toPrecision.call(that, precision);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.assign.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.assign.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.3.1 Object.assign(target, source)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S + $export.F, 'Object', { assign: __webpack_require__(/*! ./_object-assign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-assign.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.create.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.create.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+$export($export.S, 'Object', { create: __webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.define-properties.js":
+/*!**************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.define-properties.js ***!
+ \**************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+// 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties)
+$export($export.S + $export.F * !__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js"), 'Object', { defineProperties: __webpack_require__(/*! ./_object-dps */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dps.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.define-property.js":
+/*!************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.define-property.js ***!
+ \************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
+$export($export.S + $export.F * !__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js"), 'Object', { defineProperty: __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.freeze.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.freeze.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.5 Object.freeze(O)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var meta = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js").onFreeze;
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('freeze', function ($freeze) {
+ return function freeze(it) {
+ return $freeze && isObject(it) ? $freeze(meta(it)) : it;
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-own-property-descriptor.js":
+/*!************************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-own-property-descriptor.js ***!
+ \************************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var $getOwnPropertyDescriptor = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js").f;
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('getOwnPropertyDescriptor', function () {
+ return function getOwnPropertyDescriptor(it, key) {
+ return $getOwnPropertyDescriptor(toIObject(it), key);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-own-property-names.js":
+/*!*******************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-own-property-names.js ***!
+ \*******************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.7 Object.getOwnPropertyNames(O)
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('getOwnPropertyNames', function () {
+ return __webpack_require__(/*! ./_object-gopn-ext */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn-ext.js").f;
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-prototype-of.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-prototype-of.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.9 Object.getPrototypeOf(O)
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var $getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('getPrototypeOf', function () {
+ return function getPrototypeOf(it) {
+ return $getPrototypeOf(toObject(it));
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-extensible.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-extensible.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.11 Object.isExtensible(O)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('isExtensible', function ($isExtensible) {
+ return function isExtensible(it) {
+ return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false;
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-frozen.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-frozen.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.12 Object.isFrozen(O)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('isFrozen', function ($isFrozen) {
+ return function isFrozen(it) {
+ return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true;
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-sealed.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-sealed.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.13 Object.isSealed(O)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('isSealed', function ($isSealed) {
+ return function isSealed(it) {
+ return isObject(it) ? $isSealed ? $isSealed(it) : false : true;
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.3.10 Object.is(value1, value2)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+$export($export.S, 'Object', { is: __webpack_require__(/*! ./_same-value */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_same-value.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.keys.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.keys.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.14 Object.keys(O)
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var $keys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('keys', function () {
+ return function keys(it) {
+ return $keys(toObject(it));
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.prevent-extensions.js":
+/*!***************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.prevent-extensions.js ***!
+ \***************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.15 Object.preventExtensions(O)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var meta = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js").onFreeze;
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('preventExtensions', function ($preventExtensions) {
+ return function preventExtensions(it) {
+ return $preventExtensions && isObject(it) ? $preventExtensions(meta(it)) : it;
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.seal.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.seal.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.17 Object.seal(O)
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var meta = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js").onFreeze;
+
+__webpack_require__(/*! ./_object-sap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-sap.js")('seal', function ($seal) {
+ return function seal(it) {
+ return $seal && isObject(it) ? $seal(meta(it)) : it;
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.set-prototype-of.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.set-prototype-of.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.3.19 Object.setPrototypeOf(O, proto)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+$export($export.S, 'Object', { setPrototypeOf: __webpack_require__(/*! ./_set-proto */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-proto.js").set });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.to-string.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.to-string.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 19.1.3.6 Object.prototype.toString()
+var classof = __webpack_require__(/*! ./_classof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js");
+var test = {};
+test[__webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('toStringTag')] = 'z';
+if (test + '' != '[object z]') {
+ __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js")(Object.prototype, 'toString', function toString() {
+ return '[object ' + classof(this) + ']';
+ }, true);
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.parse-float.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.parse-float.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $parseFloat = __webpack_require__(/*! ./_parse-float */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-float.js");
+// 18.2.4 parseFloat(string)
+$export($export.G + $export.F * (parseFloat != $parseFloat), { parseFloat: $parseFloat });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.parse-int.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.parse-int.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $parseInt = __webpack_require__(/*! ./_parse-int */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_parse-int.js");
+// 18.2.5 parseInt(string, radix)
+$export($export.G + $export.F * (parseInt != $parseInt), { parseInt: $parseInt });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.promise.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.promise.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js");
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_ctx.js");
+var classof = __webpack_require__(/*! ./_classof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_classof.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js");
+var task = __webpack_require__(/*! ./_task */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_task.js").set;
+var microtask = __webpack_require__(/*! ./_microtask */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_microtask.js")();
+var newPromiseCapabilityModule = __webpack_require__(/*! ./_new-promise-capability */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_new-promise-capability.js");
+var perform = __webpack_require__(/*! ./_perform */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_perform.js");
+var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_user-agent.js");
+var promiseResolve = __webpack_require__(/*! ./_promise-resolve */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_promise-resolve.js");
+var PROMISE = 'Promise';
+var TypeError = global.TypeError;
+var process = global.process;
+var versions = process && process.versions;
+var v8 = versions && versions.v8 || '';
+var $Promise = global[PROMISE];
+var isNode = classof(process) == 'process';
+var empty = function () { /* empty */ };
+var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
+var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;
+
+var USE_NATIVE = !!function () {
+ try {
+ // correct subclassing with @@species support
+ var promise = $Promise.resolve(1);
+ var FakePromise = (promise.constructor = {})[__webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('species')] = function (exec) {
+ exec(empty, empty);
+ };
+ // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+ return (isNode || typeof PromiseRejectionEvent == 'function')
+ && promise.then(empty) instanceof FakePromise
+ // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+ // we can't detect it synchronously, so just check versions
+ && v8.indexOf('6.6') !== 0
+ && userAgent.indexOf('Chrome/66') === -1;
+ } catch (e) { /* empty */ }
+}();
+
+// helpers
+var isThenable = function (it) {
+ var then;
+ return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var notify = function (promise, isReject) {
+ if (promise._n) return;
+ promise._n = true;
+ var chain = promise._c;
+ microtask(function () {
+ var value = promise._v;
+ var ok = promise._s == 1;
+ var i = 0;
+ var run = function (reaction) {
+ var handler = ok ? reaction.ok : reaction.fail;
+ var resolve = reaction.resolve;
+ var reject = reaction.reject;
+ var domain = reaction.domain;
+ var result, then, exited;
+ try {
+ if (handler) {
+ if (!ok) {
+ if (promise._h == 2) onHandleUnhandled(promise);
+ promise._h = 1;
+ }
+ if (handler === true) result = value;
+ else {
+ if (domain) domain.enter();
+ result = handler(value); // may throw
+ if (domain) {
+ domain.exit();
+ exited = true;
+ }
+ }
+ if (result === reaction.promise) {
+ reject(TypeError('Promise-chain cycle'));
+ } else if (then = isThenable(result)) {
+ then.call(result, resolve, reject);
+ } else resolve(result);
+ } else reject(value);
+ } catch (e) {
+ if (domain && !exited) domain.exit();
+ reject(e);
+ }
+ };
+ while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
+ promise._c = [];
+ promise._n = false;
+ if (isReject && !promise._h) onUnhandled(promise);
+ });
+};
+var onUnhandled = function (promise) {
+ task.call(global, function () {
+ var value = promise._v;
+ var unhandled = isUnhandled(promise);
+ var result, handler, console;
+ if (unhandled) {
+ result = perform(function () {
+ if (isNode) {
+ process.emit('unhandledRejection', value, promise);
+ } else if (handler = global.onunhandledrejection) {
+ handler({ promise: promise, reason: value });
+ } else if ((console = global.console) && console.error) {
+ console.error('Unhandled promise rejection', value);
+ }
+ });
+ // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+ promise._h = isNode || isUnhandled(promise) ? 2 : 1;
+ } promise._a = undefined;
+ if (unhandled && result.e) throw result.v;
+ });
+};
+var isUnhandled = function (promise) {
+ return promise._h !== 1 && (promise._a || promise._c).length === 0;
+};
+var onHandleUnhandled = function (promise) {
+ task.call(global, function () {
+ var handler;
+ if (isNode) {
+ process.emit('rejectionHandled', promise);
+ } else if (handler = global.onrejectionhandled) {
+ handler({ promise: promise, reason: promise._v });
+ }
+ });
+};
+var $reject = function (value) {
+ var promise = this;
+ if (promise._d) return;
+ promise._d = true;
+ promise = promise._w || promise; // unwrap
+ promise._v = value;
+ promise._s = 2;
+ if (!promise._a) promise._a = promise._c.slice();
+ notify(promise, true);
+};
+var $resolve = function (value) {
+ var promise = this;
+ var then;
+ if (promise._d) return;
+ promise._d = true;
+ promise = promise._w || promise; // unwrap
+ try {
+ if (promise === value) throw TypeError("Promise can't be resolved itself");
+ if (then = isThenable(value)) {
+ microtask(function () {
+ var wrapper = { _w: promise, _d: false }; // wrap
+ try {
+ then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
+ } catch (e) {
+ $reject.call(wrapper, e);
+ }
+ });
+ } else {
+ promise._v = value;
+ promise._s = 1;
+ notify(promise, false);
+ }
+ } catch (e) {
+ $reject.call({ _w: promise, _d: false }, e); // wrap
+ }
+};
+
+// constructor polyfill
+if (!USE_NATIVE) {
+ // 25.4.3.1 Promise(executor)
+ $Promise = function Promise(executor) {
+ anInstance(this, $Promise, PROMISE, '_h');
+ aFunction(executor);
+ Internal.call(this);
+ try {
+ executor(ctx($resolve, this, 1), ctx($reject, this, 1));
+ } catch (err) {
+ $reject.call(this, err);
+ }
+ };
+ // eslint-disable-next-line no-unused-vars
+ Internal = function Promise(executor) {
+ this._c = []; // <- awaiting reactions
+ this._a = undefined; // <- checked in isUnhandled reactions
+ this._s = 0; // <- state
+ this._d = false; // <- done
+ this._v = undefined; // <- value
+ this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
+ this._n = false; // <- notify
+ };
+ Internal.prototype = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js")($Promise.prototype, {
+ // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
+ then: function then(onFulfilled, onRejected) {
+ var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
+ reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+ reaction.fail = typeof onRejected == 'function' && onRejected;
+ reaction.domain = isNode ? process.domain : undefined;
+ this._c.push(reaction);
+ if (this._a) this._a.push(reaction);
+ if (this._s) notify(this, false);
+ return reaction.promise;
+ },
+ // 25.4.5.1 Promise.prototype.catch(onRejected)
+ 'catch': function (onRejected) {
+ return this.then(undefined, onRejected);
+ }
+ });
+ OwnPromiseCapability = function () {
+ var promise = new Internal();
+ this.promise = promise;
+ this.resolve = ctx($resolve, promise, 1);
+ this.reject = ctx($reject, promise, 1);
+ };
+ newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+ return C === $Promise || C === Wrapper
+ ? new OwnPromiseCapability(C)
+ : newGenericPromiseCapability(C);
+ };
+}
+
+$export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
+__webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js")($Promise, PROMISE);
+__webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js")(PROMISE);
+Wrapper = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js")[PROMISE];
+
+// statics
+$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
+ // 25.4.4.5 Promise.reject(r)
+ reject: function reject(r) {
+ var capability = newPromiseCapability(this);
+ var $$reject = capability.reject;
+ $$reject(r);
+ return capability.promise;
+ }
+});
+$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
+ // 25.4.4.6 Promise.resolve(x)
+ resolve: function resolve(x) {
+ return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);
+ }
+});
+$export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(/*! ./_iter-detect */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-detect.js")(function (iter) {
+ $Promise.all(iter)['catch'](empty);
+})), PROMISE, {
+ // 25.4.4.1 Promise.all(iterable)
+ all: function all(iterable) {
+ var C = this;
+ var capability = newPromiseCapability(C);
+ var resolve = capability.resolve;
+ var reject = capability.reject;
+ var result = perform(function () {
+ var values = [];
+ var index = 0;
+ var remaining = 1;
+ forOf(iterable, false, function (promise) {
+ var $index = index++;
+ var alreadyCalled = false;
+ values.push(undefined);
+ remaining++;
+ C.resolve(promise).then(function (value) {
+ if (alreadyCalled) return;
+ alreadyCalled = true;
+ values[$index] = value;
+ --remaining || resolve(values);
+ }, reject);
+ });
+ --remaining || resolve(values);
+ });
+ if (result.e) reject(result.v);
+ return capability.promise;
+ },
+ // 25.4.4.4 Promise.race(iterable)
+ race: function race(iterable) {
+ var C = this;
+ var capability = newPromiseCapability(C);
+ var reject = capability.reject;
+ var result = perform(function () {
+ forOf(iterable, false, function (promise) {
+ C.resolve(promise).then(capability.resolve, reject);
+ });
+ });
+ if (result.e) reject(result.v);
+ return capability.promise;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.apply.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.apply.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var rApply = (__webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").Reflect || {}).apply;
+var fApply = Function.apply;
+// MS Edge argumentsList argument is optional
+$export($export.S + $export.F * !__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ rApply(function () { /* empty */ });
+}), 'Reflect', {
+ apply: function apply(target, thisArgument, argumentsList) {
+ var T = aFunction(target);
+ var L = anObject(argumentsList);
+ return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.construct.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.construct.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var create = __webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var bind = __webpack_require__(/*! ./_bind */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_bind.js");
+var rConstruct = (__webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").Reflect || {}).construct;
+
+// MS Edge supports only 2 arguments and argumentsList argument is optional
+// FF Nightly sets third argument as `new.target`, but does not create `this` from it
+var NEW_TARGET_BUG = fails(function () {
+ function F() { /* empty */ }
+ return !(rConstruct(function () { /* empty */ }, [], F) instanceof F);
+});
+var ARGS_BUG = !fails(function () {
+ rConstruct(function () { /* empty */ });
+});
+
+$export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', {
+ construct: function construct(Target, args /* , newTarget */) {
+ aFunction(Target);
+ anObject(args);
+ var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
+ if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget);
+ if (Target == newTarget) {
+ // w/o altered newTarget, optimization for 0-4 arguments
+ switch (args.length) {
+ case 0: return new Target();
+ case 1: return new Target(args[0]);
+ case 2: return new Target(args[0], args[1]);
+ case 3: return new Target(args[0], args[1], args[2]);
+ case 4: return new Target(args[0], args[1], args[2], args[3]);
+ }
+ // w/o altered newTarget, lot of arguments case
+ var $args = [null];
+ $args.push.apply($args, args);
+ return new (bind.apply(Target, $args))();
+ }
+ // with altered newTarget, not support built-in constructors
+ var proto = newTarget.prototype;
+ var instance = create(isObject(proto) ? proto : Object.prototype);
+ var result = Function.apply.call(Target, instance, args);
+ return isObject(result) ? result : instance;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.define-property.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.define-property.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+
+// MS Edge has broken Reflect.defineProperty - throwing instead of returning false
+$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ // eslint-disable-next-line no-undef
+ Reflect.defineProperty(dP.f({}, 1, { value: 1 }), 1, { value: 2 });
+}), 'Reflect', {
+ defineProperty: function defineProperty(target, propertyKey, attributes) {
+ anObject(target);
+ propertyKey = toPrimitive(propertyKey, true);
+ anObject(attributes);
+ try {
+ dP.f(target, propertyKey, attributes);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.delete-property.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.delete-property.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.4 Reflect.deleteProperty(target, propertyKey)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js").f;
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+
+$export($export.S, 'Reflect', {
+ deleteProperty: function deleteProperty(target, propertyKey) {
+ var desc = gOPD(anObject(target), propertyKey);
+ return desc && !desc.configurable ? false : delete target[propertyKey];
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.enumerate.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.enumerate.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 26.1.5 Reflect.enumerate(target)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var Enumerate = function (iterated) {
+ this._t = anObject(iterated); // target
+ this._i = 0; // next index
+ var keys = this._k = []; // keys
+ var key;
+ for (key in iterated) keys.push(key);
+};
+__webpack_require__(/*! ./_iter-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-create.js")(Enumerate, 'Object', function () {
+ var that = this;
+ var keys = that._k;
+ var key;
+ do {
+ if (that._i >= keys.length) return { value: undefined, done: true };
+ } while (!((key = keys[that._i++]) in that._t));
+ return { value: key, done: false };
+});
+
+$export($export.S, 'Reflect', {
+ enumerate: function enumerate(target) {
+ return new Enumerate(target);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js":
+/*!*************************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js ***!
+ \*************************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
+var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+
+$export($export.S, 'Reflect', {
+ getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {
+ return gOPD.f(anObject(target), propertyKey);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get-prototype-of.js":
+/*!**************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get-prototype-of.js ***!
+ \**************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.8 Reflect.getPrototypeOf(target)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var getProto = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+
+$export($export.S, 'Reflect', {
+ getPrototypeOf: function getPrototypeOf(target) {
+ return getProto(anObject(target));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.6 Reflect.get(target, propertyKey [, receiver])
+var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+
+function get(target, propertyKey /* , receiver */) {
+ var receiver = arguments.length < 3 ? target : arguments[2];
+ var desc, proto;
+ if (anObject(target) === receiver) return target[propertyKey];
+ if (desc = gOPD.f(target, propertyKey)) return has(desc, 'value')
+ ? desc.value
+ : desc.get !== undefined
+ ? desc.get.call(receiver)
+ : undefined;
+ if (isObject(proto = getPrototypeOf(target))) return get(proto, propertyKey, receiver);
+}
+
+$export($export.S, 'Reflect', { get: get });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.has.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.has.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.9 Reflect.has(target, propertyKey)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Reflect', {
+ has: function has(target, propertyKey) {
+ return propertyKey in target;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.is-extensible.js":
+/*!***********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.is-extensible.js ***!
+ \***********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.10 Reflect.isExtensible(target)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var $isExtensible = Object.isExtensible;
+
+$export($export.S, 'Reflect', {
+ isExtensible: function isExtensible(target) {
+ anObject(target);
+ return $isExtensible ? $isExtensible(target) : true;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.own-keys.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.own-keys.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.11 Reflect.ownKeys(target)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Reflect', { ownKeys: __webpack_require__(/*! ./_own-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_own-keys.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.prevent-extensions.js":
+/*!****************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.prevent-extensions.js ***!
+ \****************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.12 Reflect.preventExtensions(target)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var $preventExtensions = Object.preventExtensions;
+
+$export($export.S, 'Reflect', {
+ preventExtensions: function preventExtensions(target) {
+ anObject(target);
+ try {
+ if ($preventExtensions) $preventExtensions(target);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.set-prototype-of.js":
+/*!**************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.set-prototype-of.js ***!
+ \**************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.14 Reflect.setPrototypeOf(target, proto)
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var setProto = __webpack_require__(/*! ./_set-proto */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-proto.js");
+
+if (setProto) $export($export.S, 'Reflect', {
+ setPrototypeOf: function setPrototypeOf(target, proto) {
+ setProto.check(target, proto);
+ try {
+ setProto.set(target, proto);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.set.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.set.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+
+function set(target, propertyKey, V /* , receiver */) {
+ var receiver = arguments.length < 4 ? target : arguments[3];
+ var ownDesc = gOPD.f(anObject(target), propertyKey);
+ var existingDescriptor, proto;
+ if (!ownDesc) {
+ if (isObject(proto = getPrototypeOf(target))) {
+ return set(proto, propertyKey, V, receiver);
+ }
+ ownDesc = createDesc(0);
+ }
+ if (has(ownDesc, 'value')) {
+ if (ownDesc.writable === false || !isObject(receiver)) return false;
+ if (existingDescriptor = gOPD.f(receiver, propertyKey)) {
+ if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;
+ existingDescriptor.value = V;
+ dP.f(receiver, propertyKey, existingDescriptor);
+ } else dP.f(receiver, propertyKey, createDesc(0, V));
+ return true;
+ }
+ return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
+}
+
+$export($export.S, 'Reflect', { set: set });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.constructor.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.constructor.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var inheritIfRequired = __webpack_require__(/*! ./_inherit-if-required */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_inherit-if-required.js");
+var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f;
+var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js").f;
+var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-regexp.js");
+var $flags = __webpack_require__(/*! ./_flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js");
+var $RegExp = global.RegExp;
+var Base = $RegExp;
+var proto = $RegExp.prototype;
+var re1 = /a/g;
+var re2 = /a/g;
+// "new" creates a new object, old webkit buggy here
+var CORRECT_NEW = new $RegExp(re1) !== re1;
+
+if (__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && (!CORRECT_NEW || __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ re2[__webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('match')] = false;
+ // RegExp constructor can alter flags and IsRegExp works correct with @@match
+ return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i';
+}))) {
+ $RegExp = function RegExp(p, f) {
+ var tiRE = this instanceof $RegExp;
+ var piRE = isRegExp(p);
+ var fiU = f === undefined;
+ return !tiRE && piRE && p.constructor === $RegExp && fiU ? p
+ : inheritIfRequired(CORRECT_NEW
+ ? new Base(piRE && !fiU ? p.source : p, f)
+ : Base((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? $flags.call(p) : f)
+ , tiRE ? this : proto, $RegExp);
+ };
+ var proxy = function (key) {
+ key in $RegExp || dP($RegExp, key, {
+ configurable: true,
+ get: function () { return Base[key]; },
+ set: function (it) { Base[key] = it; }
+ });
+ };
+ for (var keys = gOPN(Base), i = 0; keys.length > i;) proxy(keys[i++]);
+ proto.constructor = $RegExp;
+ $RegExp.prototype = proto;
+ __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js")(global, 'RegExp', $RegExp);
+}
+
+__webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js")('RegExp');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.exec.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.exec.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var regexpExec = __webpack_require__(/*! ./_regexp-exec */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec.js");
+__webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js")({
+ target: 'RegExp',
+ proto: true,
+ forced: regexpExec !== /./.exec
+}, {
+ exec: regexpExec
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.flags.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.flags.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 21.2.5.3 get RegExp.prototype.flags()
+if (__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && /./g.flags != 'g') __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js").f(RegExp.prototype, 'flags', {
+ configurable: true,
+ get: __webpack_require__(/*! ./_flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js")
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.match.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.match.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var advanceStringIndex = __webpack_require__(/*! ./_advance-string-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_advance-string-index.js");
+var regExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec-abstract.js");
+
+// @@match logic
+__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fix-re-wks.js")('match', 1, function (defined, MATCH, $match, maybeCallNative) {
+ return [
+ // `String.prototype.match` method
+ // https://tc39.github.io/ecma262/#sec-string.prototype.match
+ function match(regexp) {
+ var O = defined(this);
+ var fn = regexp == undefined ? undefined : regexp[MATCH];
+ return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
+ },
+ // `RegExp.prototype[@@match]` method
+ // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match
+ function (regexp) {
+ var res = maybeCallNative($match, regexp, this);
+ if (res.done) return res.value;
+ var rx = anObject(regexp);
+ var S = String(this);
+ if (!rx.global) return regExpExec(rx, S);
+ var fullUnicode = rx.unicode;
+ rx.lastIndex = 0;
+ var A = [];
+ var n = 0;
+ var result;
+ while ((result = regExpExec(rx, S)) !== null) {
+ var matchStr = String(result[0]);
+ A[n] = matchStr;
+ if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
+ n++;
+ }
+ return n === 0 ? null : A;
+ }
+ ];
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.replace.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.replace.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var advanceStringIndex = __webpack_require__(/*! ./_advance-string-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_advance-string-index.js");
+var regExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec-abstract.js");
+var max = Math.max;
+var min = Math.min;
+var floor = Math.floor;
+var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g;
+var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g;
+
+var maybeToString = function (it) {
+ return it === undefined ? it : String(it);
+};
+
+// @@replace logic
+__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fix-re-wks.js")('replace', 2, function (defined, REPLACE, $replace, maybeCallNative) {
+ return [
+ // `String.prototype.replace` method
+ // https://tc39.github.io/ecma262/#sec-string.prototype.replace
+ function replace(searchValue, replaceValue) {
+ var O = defined(this);
+ var fn = searchValue == undefined ? undefined : searchValue[REPLACE];
+ return fn !== undefined
+ ? fn.call(searchValue, O, replaceValue)
+ : $replace.call(String(O), searchValue, replaceValue);
+ },
+ // `RegExp.prototype[@@replace]` method
+ // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace
+ function (regexp, replaceValue) {
+ var res = maybeCallNative($replace, regexp, this, replaceValue);
+ if (res.done) return res.value;
+
+ var rx = anObject(regexp);
+ var S = String(this);
+ var functionalReplace = typeof replaceValue === 'function';
+ if (!functionalReplace) replaceValue = String(replaceValue);
+ var global = rx.global;
+ if (global) {
+ var fullUnicode = rx.unicode;
+ rx.lastIndex = 0;
+ }
+ var results = [];
+ while (true) {
+ var result = regExpExec(rx, S);
+ if (result === null) break;
+ results.push(result);
+ if (!global) break;
+ var matchStr = String(result[0]);
+ if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
+ }
+ var accumulatedResult = '';
+ var nextSourcePosition = 0;
+ for (var i = 0; i < results.length; i++) {
+ result = results[i];
+ var matched = String(result[0]);
+ var position = max(min(toInteger(result.index), S.length), 0);
+ var captures = [];
+ // NOTE: This is equivalent to
+ // captures = result.slice(1).map(maybeToString)
+ // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
+ // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
+ // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
+ for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));
+ var namedCaptures = result.groups;
+ if (functionalReplace) {
+ var replacerArgs = [matched].concat(captures, position, S);
+ if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
+ var replacement = String(replaceValue.apply(undefined, replacerArgs));
+ } else {
+ replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
+ }
+ if (position >= nextSourcePosition) {
+ accumulatedResult += S.slice(nextSourcePosition, position) + replacement;
+ nextSourcePosition = position + matched.length;
+ }
+ }
+ return accumulatedResult + S.slice(nextSourcePosition);
+ }
+ ];
+
+ // https://tc39.github.io/ecma262/#sec-getsubstitution
+ function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
+ var tailPos = position + matched.length;
+ var m = captures.length;
+ var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
+ if (namedCaptures !== undefined) {
+ namedCaptures = toObject(namedCaptures);
+ symbols = SUBSTITUTION_SYMBOLS;
+ }
+ return $replace.call(replacement, symbols, function (match, ch) {
+ var capture;
+ switch (ch.charAt(0)) {
+ case '$': return '$';
+ case '&': return matched;
+ case '`': return str.slice(0, position);
+ case "'": return str.slice(tailPos);
+ case '<':
+ capture = namedCaptures[ch.slice(1, -1)];
+ break;
+ default: // \d\d?
+ var n = +ch;
+ if (n === 0) return match;
+ if (n > m) {
+ var f = floor(n / 10);
+ if (f === 0) return match;
+ if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
+ return match;
+ }
+ capture = captures[n - 1];
+ }
+ return capture === undefined ? '' : capture;
+ });
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.search.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.search.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var sameValue = __webpack_require__(/*! ./_same-value */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_same-value.js");
+var regExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec-abstract.js");
+
+// @@search logic
+__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fix-re-wks.js")('search', 1, function (defined, SEARCH, $search, maybeCallNative) {
+ return [
+ // `String.prototype.search` method
+ // https://tc39.github.io/ecma262/#sec-string.prototype.search
+ function search(regexp) {
+ var O = defined(this);
+ var fn = regexp == undefined ? undefined : regexp[SEARCH];
+ return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
+ },
+ // `RegExp.prototype[@@search]` method
+ // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search
+ function (regexp) {
+ var res = maybeCallNative($search, regexp, this);
+ if (res.done) return res.value;
+ var rx = anObject(regexp);
+ var S = String(this);
+ var previousLastIndex = rx.lastIndex;
+ if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;
+ var result = regExpExec(rx, S);
+ if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;
+ return result === null ? -1 : result.index;
+ }
+ ];
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.split.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.split.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-regexp.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js");
+var advanceStringIndex = __webpack_require__(/*! ./_advance-string-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_advance-string-index.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var callRegExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec-abstract.js");
+var regexpExec = __webpack_require__(/*! ./_regexp-exec */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_regexp-exec.js");
+var fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var $min = Math.min;
+var $push = [].push;
+var $SPLIT = 'split';
+var LENGTH = 'length';
+var LAST_INDEX = 'lastIndex';
+var MAX_UINT32 = 0xffffffff;
+
+// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError
+var SUPPORTS_Y = !fails(function () { RegExp(MAX_UINT32, 'y'); });
+
+// @@split logic
+__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fix-re-wks.js")('split', 2, function (defined, SPLIT, $split, maybeCallNative) {
+ var internalSplit;
+ if (
+ 'abbc'[$SPLIT](/(b)*/)[1] == 'c' ||
+ 'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 ||
+ 'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 ||
+ '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 ||
+ '.'[$SPLIT](/()()/)[LENGTH] > 1 ||
+ ''[$SPLIT](/.?/)[LENGTH]
+ ) {
+ // based on es5-shim implementation, need to rework it
+ internalSplit = function (separator, limit) {
+ var string = String(this);
+ if (separator === undefined && limit === 0) return [];
+ // If `separator` is not a regex, use native split
+ if (!isRegExp(separator)) return $split.call(string, separator, limit);
+ var output = [];
+ var flags = (separator.ignoreCase ? 'i' : '') +
+ (separator.multiline ? 'm' : '') +
+ (separator.unicode ? 'u' : '') +
+ (separator.sticky ? 'y' : '');
+ var lastLastIndex = 0;
+ var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0;
+ // Make `global` and avoid `lastIndex` issues by working with a copy
+ var separatorCopy = new RegExp(separator.source, flags + 'g');
+ var match, lastIndex, lastLength;
+ while (match = regexpExec.call(separatorCopy, string)) {
+ lastIndex = separatorCopy[LAST_INDEX];
+ if (lastIndex > lastLastIndex) {
+ output.push(string.slice(lastLastIndex, match.index));
+ if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1));
+ lastLength = match[0][LENGTH];
+ lastLastIndex = lastIndex;
+ if (output[LENGTH] >= splitLimit) break;
+ }
+ if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++; // Avoid an infinite loop
+ }
+ if (lastLastIndex === string[LENGTH]) {
+ if (lastLength || !separatorCopy.test('')) output.push('');
+ } else output.push(string.slice(lastLastIndex));
+ return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;
+ };
+ // Chakra, V8
+ } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) {
+ internalSplit = function (separator, limit) {
+ return separator === undefined && limit === 0 ? [] : $split.call(this, separator, limit);
+ };
+ } else {
+ internalSplit = $split;
+ }
+
+ return [
+ // `String.prototype.split` method
+ // https://tc39.github.io/ecma262/#sec-string.prototype.split
+ function split(separator, limit) {
+ var O = defined(this);
+ var splitter = separator == undefined ? undefined : separator[SPLIT];
+ return splitter !== undefined
+ ? splitter.call(separator, O, limit)
+ : internalSplit.call(String(O), separator, limit);
+ },
+ // `RegExp.prototype[@@split]` method
+ // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split
+ //
+ // NOTE: This cannot be properly polyfilled in engines that don't support
+ // the 'y' flag.
+ function (regexp, limit) {
+ var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== $split);
+ if (res.done) return res.value;
+
+ var rx = anObject(regexp);
+ var S = String(this);
+ var C = speciesConstructor(rx, RegExp);
+
+ var unicodeMatching = rx.unicode;
+ var flags = (rx.ignoreCase ? 'i' : '') +
+ (rx.multiline ? 'm' : '') +
+ (rx.unicode ? 'u' : '') +
+ (SUPPORTS_Y ? 'y' : 'g');
+
+ // ^(? + rx + ) is needed, in combination with some S slicing, to
+ // simulate the 'y' flag.
+ var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags);
+ var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+ if (lim === 0) return [];
+ if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
+ var p = 0;
+ var q = 0;
+ var A = [];
+ while (q < S.length) {
+ splitter.lastIndex = SUPPORTS_Y ? q : 0;
+ var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q));
+ var e;
+ if (
+ z === null ||
+ (e = $min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p
+ ) {
+ q = advanceStringIndex(S, q, unicodeMatching);
+ } else {
+ A.push(S.slice(p, q));
+ if (A.length === lim) return A;
+ for (var i = 1; i <= z.length - 1; i++) {
+ A.push(z[i]);
+ if (A.length === lim) return A;
+ }
+ q = p = e;
+ }
+ }
+ A.push(S.slice(p));
+ return A;
+ }
+ ];
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.to-string.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.to-string.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+__webpack_require__(/*! ./es6.regexp.flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.flags.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var $flags = __webpack_require__(/*! ./_flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js");
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var TO_STRING = 'toString';
+var $toString = /./[TO_STRING];
+
+var define = function (fn) {
+ __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js")(RegExp.prototype, TO_STRING, fn, true);
+};
+
+// 21.2.5.14 RegExp.prototype.toString()
+if (__webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () { return $toString.call({ source: 'a', flags: 'b' }) != '/a/b'; })) {
+ define(function toString() {
+ var R = anObject(this);
+ return '/'.concat(R.source, '/',
+ 'flags' in R ? R.flags : !DESCRIPTORS && R instanceof RegExp ? $flags.call(R) : undefined);
+ });
+// FF44- RegExp#toString has a wrong name
+} else if ($toString.name != TO_STRING) {
+ define(function toString() {
+ return $toString.call(this);
+ });
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.set.js":
+/*!*****************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.set.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var strong = __webpack_require__(/*! ./_collection-strong */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-strong.js");
+var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var SET = 'Set';
+
+// 23.2 Set Objects
+module.exports = __webpack_require__(/*! ./_collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection.js")(SET, function (get) {
+ return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+}, {
+ // 23.2.3.1 Set.prototype.add(value)
+ add: function add(value) {
+ return strong.def(validate(this, SET), value = value === 0 ? 0 : value, value);
+ }
+}, strong);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.anchor.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.anchor.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.2 String.prototype.anchor(name)
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('anchor', function (createHTML) {
+ return function anchor(name) {
+ return createHTML(this, 'a', 'name', name);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.big.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.big.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.3 String.prototype.big()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('big', function (createHTML) {
+ return function big() {
+ return createHTML(this, 'big', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.blink.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.blink.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.4 String.prototype.blink()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('blink', function (createHTML) {
+ return function blink() {
+ return createHTML(this, 'blink', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.bold.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.bold.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.5 String.prototype.bold()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('bold', function (createHTML) {
+ return function bold() {
+ return createHTML(this, 'b', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.code-point-at.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.code-point-at.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $at = __webpack_require__(/*! ./_string-at */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-at.js")(false);
+$export($export.P, 'String', {
+ // 21.1.3.3 String.prototype.codePointAt(pos)
+ codePointAt: function codePointAt(pos) {
+ return $at(this, pos);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.ends-with.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.ends-with.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var context = __webpack_require__(/*! ./_string-context */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-context.js");
+var ENDS_WITH = 'endsWith';
+var $endsWith = ''[ENDS_WITH];
+
+$export($export.P + $export.F * __webpack_require__(/*! ./_fails-is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails-is-regexp.js")(ENDS_WITH), 'String', {
+ endsWith: function endsWith(searchString /* , endPosition = @length */) {
+ var that = context(this, searchString, ENDS_WITH);
+ var endPosition = arguments.length > 1 ? arguments[1] : undefined;
+ var len = toLength(that.length);
+ var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
+ var search = String(searchString);
+ return $endsWith
+ ? $endsWith.call(that, search, end)
+ : that.slice(end - search.length, end) === search;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fixed.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fixed.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.6 String.prototype.fixed()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('fixed', function (createHTML) {
+ return function fixed() {
+ return createHTML(this, 'tt', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fontcolor.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fontcolor.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.7 String.prototype.fontcolor(color)
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('fontcolor', function (createHTML) {
+ return function fontcolor(color) {
+ return createHTML(this, 'font', 'color', color);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fontsize.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fontsize.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.8 String.prototype.fontsize(size)
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('fontsize', function (createHTML) {
+ return function fontsize(size) {
+ return createHTML(this, 'font', 'size', size);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.from-code-point.js":
+/*!************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.from-code-point.js ***!
+ \************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+var fromCharCode = String.fromCharCode;
+var $fromCodePoint = String.fromCodePoint;
+
+// length should be 1, old FF problem
+$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
+ // 21.1.2.2 String.fromCodePoint(...codePoints)
+ fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars
+ var res = [];
+ var aLen = arguments.length;
+ var i = 0;
+ var code;
+ while (aLen > i) {
+ code = +arguments[i++];
+ if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');
+ res.push(code < 0x10000
+ ? fromCharCode(code)
+ : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
+ );
+ } return res.join('');
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.includes.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.includes.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// 21.1.3.7 String.prototype.includes(searchString, position = 0)
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var context = __webpack_require__(/*! ./_string-context */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-context.js");
+var INCLUDES = 'includes';
+
+$export($export.P + $export.F * __webpack_require__(/*! ./_fails-is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails-is-regexp.js")(INCLUDES), 'String', {
+ includes: function includes(searchString /* , position = 0 */) {
+ return !!~context(this, searchString, INCLUDES)
+ .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.italics.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.italics.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.9 String.prototype.italics()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('italics', function (createHTML) {
+ return function italics() {
+ return createHTML(this, 'i', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.iterator.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.iterator.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $at = __webpack_require__(/*! ./_string-at */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-at.js")(true);
+
+// 21.1.3.27 String.prototype[@@iterator]()
+__webpack_require__(/*! ./_iter-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-define.js")(String, 'String', function (iterated) {
+ this._t = String(iterated); // target
+ this._i = 0; // next index
+// 21.1.5.2.1 %StringIteratorPrototype%.next()
+}, function () {
+ var O = this._t;
+ var index = this._i;
+ var point;
+ if (index >= O.length) return { value: undefined, done: true };
+ point = $at(O, index);
+ this._i += point.length;
+ return { value: point, done: false };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.link.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.link.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.10 String.prototype.link(url)
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('link', function (createHTML) {
+ return function link(url) {
+ return createHTML(this, 'a', 'href', url);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.raw.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.raw.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+
+$export($export.S, 'String', {
+ // 21.1.2.4 String.raw(callSite, ...substitutions)
+ raw: function raw(callSite) {
+ var tpl = toIObject(callSite.raw);
+ var len = toLength(tpl.length);
+ var aLen = arguments.length;
+ var res = [];
+ var i = 0;
+ while (len > i) {
+ res.push(String(tpl[i++]));
+ if (i < aLen) res.push(String(arguments[i]));
+ } return res.join('');
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.repeat.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.repeat.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.P, 'String', {
+ // 21.1.3.13 String.prototype.repeat(count)
+ repeat: __webpack_require__(/*! ./_string-repeat */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-repeat.js")
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.small.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.small.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.11 String.prototype.small()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('small', function (createHTML) {
+ return function small() {
+ return createHTML(this, 'small', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.starts-with.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.starts-with.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// 21.1.3.18 String.prototype.startsWith(searchString [, position ])
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var context = __webpack_require__(/*! ./_string-context */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-context.js");
+var STARTS_WITH = 'startsWith';
+var $startsWith = ''[STARTS_WITH];
+
+$export($export.P + $export.F * __webpack_require__(/*! ./_fails-is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails-is-regexp.js")(STARTS_WITH), 'String', {
+ startsWith: function startsWith(searchString /* , position = 0 */) {
+ var that = context(this, searchString, STARTS_WITH);
+ var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
+ var search = String(searchString);
+ return $startsWith
+ ? $startsWith.call(that, search, index)
+ : that.slice(index, index + search.length) === search;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.strike.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.strike.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.12 String.prototype.strike()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('strike', function (createHTML) {
+ return function strike() {
+ return createHTML(this, 'strike', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.sub.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.sub.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.13 String.prototype.sub()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('sub', function (createHTML) {
+ return function sub() {
+ return createHTML(this, 'sub', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.sup.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.sup.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// B.2.3.14 String.prototype.sup()
+__webpack_require__(/*! ./_string-html */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-html.js")('sup', function (createHTML) {
+ return function sup() {
+ return createHTML(this, 'sup', '', '');
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.trim.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.trim.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// 21.1.3.25 String.prototype.trim()
+__webpack_require__(/*! ./_string-trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js")('trim', function ($trim) {
+ return function trim() {
+ return $trim(this, 3);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.symbol.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.symbol.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// ECMAScript 6 symbols shim
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var has = __webpack_require__(/*! ./_has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_has.js");
+var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var META = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js").KEY;
+var $fails = __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js");
+var shared = __webpack_require__(/*! ./_shared */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_shared.js");
+var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-to-string-tag.js");
+var uid = __webpack_require__(/*! ./_uid */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_uid.js");
+var wks = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js");
+var wksExt = __webpack_require__(/*! ./_wks-ext */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-ext.js");
+var wksDefine = __webpack_require__(/*! ./_wks-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-define.js");
+var enumKeys = __webpack_require__(/*! ./_enum-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_enum-keys.js");
+var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-array.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_property-desc.js");
+var _create = __webpack_require__(/*! ./_object-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-create.js");
+var gOPNExt = __webpack_require__(/*! ./_object-gopn-ext */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn-ext.js");
+var $GOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js");
+var $GOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gops.js");
+var $DP = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+var $keys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+var gOPD = $GOPD.f;
+var dP = $DP.f;
+var gOPN = gOPNExt.f;
+var $Symbol = global.Symbol;
+var $JSON = global.JSON;
+var _stringify = $JSON && $JSON.stringify;
+var PROTOTYPE = 'prototype';
+var HIDDEN = wks('_hidden');
+var TO_PRIMITIVE = wks('toPrimitive');
+var isEnum = {}.propertyIsEnumerable;
+var SymbolRegistry = shared('symbol-registry');
+var AllSymbols = shared('symbols');
+var OPSymbols = shared('op-symbols');
+var ObjectProto = Object[PROTOTYPE];
+var USE_NATIVE = typeof $Symbol == 'function' && !!$GOPS.f;
+var QObject = global.QObject;
+// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
+var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
+
+// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
+var setSymbolDesc = DESCRIPTORS && $fails(function () {
+ return _create(dP({}, 'a', {
+ get: function () { return dP(this, 'a', { value: 7 }).a; }
+ })).a != 7;
+}) ? function (it, key, D) {
+ var protoDesc = gOPD(ObjectProto, key);
+ if (protoDesc) delete ObjectProto[key];
+ dP(it, key, D);
+ if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
+} : dP;
+
+var wrap = function (tag) {
+ var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
+ sym._k = tag;
+ return sym;
+};
+
+var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {
+ return typeof it == 'symbol';
+} : function (it) {
+ return it instanceof $Symbol;
+};
+
+var $defineProperty = function defineProperty(it, key, D) {
+ if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
+ anObject(it);
+ key = toPrimitive(key, true);
+ anObject(D);
+ if (has(AllSymbols, key)) {
+ if (!D.enumerable) {
+ if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
+ it[HIDDEN][key] = true;
+ } else {
+ if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
+ D = _create(D, { enumerable: createDesc(0, false) });
+ } return setSymbolDesc(it, key, D);
+ } return dP(it, key, D);
+};
+var $defineProperties = function defineProperties(it, P) {
+ anObject(it);
+ var keys = enumKeys(P = toIObject(P));
+ var i = 0;
+ var l = keys.length;
+ var key;
+ while (l > i) $defineProperty(it, key = keys[i++], P[key]);
+ return it;
+};
+var $create = function create(it, P) {
+ return P === undefined ? _create(it) : $defineProperties(_create(it), P);
+};
+var $propertyIsEnumerable = function propertyIsEnumerable(key) {
+ var E = isEnum.call(this, key = toPrimitive(key, true));
+ if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;
+ return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
+};
+var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
+ it = toIObject(it);
+ key = toPrimitive(key, true);
+ if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;
+ var D = gOPD(it, key);
+ if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
+ return D;
+};
+var $getOwnPropertyNames = function getOwnPropertyNames(it) {
+ var names = gOPN(toIObject(it));
+ var result = [];
+ var i = 0;
+ var key;
+ while (names.length > i) {
+ if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
+ } return result;
+};
+var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
+ var IS_OP = it === ObjectProto;
+ var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
+ var result = [];
+ var i = 0;
+ var key;
+ while (names.length > i) {
+ if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
+ } return result;
+};
+
+// 19.4.1.1 Symbol([description])
+if (!USE_NATIVE) {
+ $Symbol = function Symbol() {
+ if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
+ var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
+ var $set = function (value) {
+ if (this === ObjectProto) $set.call(OPSymbols, value);
+ if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
+ setSymbolDesc(this, tag, createDesc(1, value));
+ };
+ if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });
+ return wrap(tag);
+ };
+ redefine($Symbol[PROTOTYPE], 'toString', function toString() {
+ return this._k;
+ });
+
+ $GOPD.f = $getOwnPropertyDescriptor;
+ $DP.f = $defineProperty;
+ __webpack_require__(/*! ./_object-gopn */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopn.js").f = gOPNExt.f = $getOwnPropertyNames;
+ __webpack_require__(/*! ./_object-pie */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-pie.js").f = $propertyIsEnumerable;
+ $GOPS.f = $getOwnPropertySymbols;
+
+ if (DESCRIPTORS && !__webpack_require__(/*! ./_library */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_library.js")) {
+ redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
+ }
+
+ wksExt.f = function (name) {
+ return wrap(wks(name));
+ };
+}
+
+$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });
+
+for (var es6Symbols = (
+ // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
+ 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
+).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);
+
+for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);
+
+$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
+ // 19.4.2.1 Symbol.for(key)
+ 'for': function (key) {
+ return has(SymbolRegistry, key += '')
+ ? SymbolRegistry[key]
+ : SymbolRegistry[key] = $Symbol(key);
+ },
+ // 19.4.2.5 Symbol.keyFor(sym)
+ keyFor: function keyFor(sym) {
+ if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
+ for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
+ },
+ useSetter: function () { setter = true; },
+ useSimple: function () { setter = false; }
+});
+
+$export($export.S + $export.F * !USE_NATIVE, 'Object', {
+ // 19.1.2.2 Object.create(O [, Properties])
+ create: $create,
+ // 19.1.2.4 Object.defineProperty(O, P, Attributes)
+ defineProperty: $defineProperty,
+ // 19.1.2.3 Object.defineProperties(O, Properties)
+ defineProperties: $defineProperties,
+ // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
+ getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
+ // 19.1.2.7 Object.getOwnPropertyNames(O)
+ getOwnPropertyNames: $getOwnPropertyNames,
+ // 19.1.2.8 Object.getOwnPropertySymbols(O)
+ getOwnPropertySymbols: $getOwnPropertySymbols
+});
+
+// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
+// https://bugs.chromium.org/p/v8/issues/detail?id=3443
+var FAILS_ON_PRIMITIVES = $fails(function () { $GOPS.f(1); });
+
+$export($export.S + $export.F * FAILS_ON_PRIMITIVES, 'Object', {
+ getOwnPropertySymbols: function getOwnPropertySymbols(it) {
+ return $GOPS.f(toObject(it));
+ }
+});
+
+// 24.3.2 JSON.stringify(value [, replacer [, space]])
+$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
+ var S = $Symbol();
+ // MS Edge converts symbol values to JSON as {}
+ // WebKit converts symbol values to JSON as null
+ // V8 throws on boxed symbols
+ return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';
+})), 'JSON', {
+ stringify: function stringify(it) {
+ var args = [it];
+ var i = 1;
+ var replacer, $replacer;
+ while (arguments.length > i) args.push(arguments[i++]);
+ $replacer = replacer = args[1];
+ if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
+ if (!isArray(replacer)) replacer = function (key, value) {
+ if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
+ if (!isSymbol(value)) return value;
+ };
+ args[1] = replacer;
+ return _stringify.apply($JSON, args);
+ }
+});
+
+// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
+$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js")($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
+// 19.4.3.5 Symbol.prototype[@@toStringTag]
+setToStringTag($Symbol, 'Symbol');
+// 20.2.1.9 Math[@@toStringTag]
+setToStringTag(Math, 'Math', true);
+// 24.3.3 JSON[@@toStringTag]
+setToStringTag(global.JSON, 'JSON', true);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.array-buffer.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.array-buffer.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $typed = __webpack_require__(/*! ./_typed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed.js");
+var buffer = __webpack_require__(/*! ./_typed-buffer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-buffer.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-absolute-index.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var ArrayBuffer = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").ArrayBuffer;
+var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js");
+var $ArrayBuffer = buffer.ArrayBuffer;
+var $DataView = buffer.DataView;
+var $isView = $typed.ABV && ArrayBuffer.isView;
+var $slice = $ArrayBuffer.prototype.slice;
+var VIEW = $typed.VIEW;
+var ARRAY_BUFFER = 'ArrayBuffer';
+
+$export($export.G + $export.W + $export.F * (ArrayBuffer !== $ArrayBuffer), { ArrayBuffer: $ArrayBuffer });
+
+$export($export.S + $export.F * !$typed.CONSTR, ARRAY_BUFFER, {
+ // 24.1.3.1 ArrayBuffer.isView(arg)
+ isView: function isView(it) {
+ return $isView && $isView(it) || isObject(it) && VIEW in it;
+ }
+});
+
+$export($export.P + $export.U + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_fails.js")(function () {
+ return !new $ArrayBuffer(2).slice(1, undefined).byteLength;
+}), ARRAY_BUFFER, {
+ // 24.1.4.3 ArrayBuffer.prototype.slice(start, end)
+ slice: function slice(start, end) {
+ if ($slice !== undefined && end === undefined) return $slice.call(anObject(this), start); // FF fix
+ var len = anObject(this).byteLength;
+ var first = toAbsoluteIndex(start, len);
+ var fin = toAbsoluteIndex(end === undefined ? len : end, len);
+ var result = new (speciesConstructor(this, $ArrayBuffer))(toLength(fin - first));
+ var viewS = new $DataView(this);
+ var viewT = new $DataView(result);
+ var index = 0;
+ while (first < fin) {
+ viewT.setUint8(index++, viewS.getUint8(first++));
+ } return result;
+ }
+});
+
+__webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js")(ARRAY_BUFFER);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.data-view.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.data-view.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+$export($export.G + $export.W + $export.F * !__webpack_require__(/*! ./_typed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed.js").ABV, {
+ DataView: __webpack_require__(/*! ./_typed-buffer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-buffer.js").DataView
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.float32-array.js":
+/*!*********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.float32-array.js ***!
+ \*********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Float32', 4, function (init) {
+ return function Float32Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.float64-array.js":
+/*!*********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.float64-array.js ***!
+ \*********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Float64', 8, function (init) {
+ return function Float64Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int16-array.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int16-array.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Int16', 2, function (init) {
+ return function Int16Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int32-array.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int32-array.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Int32', 4, function (init) {
+ return function Int32Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int8-array.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int8-array.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Int8', 1, function (init) {
+ return function Int8Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint16-array.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint16-array.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Uint16', 2, function (init) {
+ return function Uint16Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint32-array.js":
+/*!********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint32-array.js ***!
+ \********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Uint32', 4, function (init) {
+ return function Uint32Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint8-array.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint8-array.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Uint8', 1, function (init) {
+ return function Uint8Array(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint8-clamped-array.js":
+/*!***************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint8-clamped-array.js ***!
+ \***************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_typed-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_typed-array.js")('Uint8', 1, function (init) {
+ return function Uint8ClampedArray(data, byteOffset, length) {
+ return init(this, data, byteOffset, length);
+ };
+}, true);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-map.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-map.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var each = __webpack_require__(/*! ./_array-methods */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-methods.js")(0);
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var meta = __webpack_require__(/*! ./_meta */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_meta.js");
+var assign = __webpack_require__(/*! ./_object-assign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-assign.js");
+var weak = __webpack_require__(/*! ./_collection-weak */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-weak.js");
+var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-object.js");
+var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var NATIVE_WEAK_MAP = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
+var WEAK_MAP = 'WeakMap';
+var getWeak = meta.getWeak;
+var isExtensible = Object.isExtensible;
+var uncaughtFrozenStore = weak.ufstore;
+var InternalMap;
+
+var wrapper = function (get) {
+ return function WeakMap() {
+ return get(this, arguments.length > 0 ? arguments[0] : undefined);
+ };
+};
+
+var methods = {
+ // 23.3.3.3 WeakMap.prototype.get(key)
+ get: function get(key) {
+ if (isObject(key)) {
+ var data = getWeak(key);
+ if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);
+ return data ? data[this._i] : undefined;
+ }
+ },
+ // 23.3.3.5 WeakMap.prototype.set(key, value)
+ set: function set(key, value) {
+ return weak.def(validate(this, WEAK_MAP), key, value);
+ }
+};
+
+// 23.3 WeakMap Objects
+var $WeakMap = module.exports = __webpack_require__(/*! ./_collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection.js")(WEAK_MAP, wrapper, methods, weak, true, true);
+
+// IE11 WeakMap frozen keys fix
+if (NATIVE_WEAK_MAP && IS_IE11) {
+ InternalMap = weak.getConstructor(wrapper, WEAK_MAP);
+ assign(InternalMap.prototype, methods);
+ meta.NEED = true;
+ each(['delete', 'has', 'get', 'set'], function (key) {
+ var proto = $WeakMap.prototype;
+ var method = proto[key];
+ redefine(proto, key, function (a, b) {
+ // store frozen objects on internal weakmap shim
+ if (isObject(a) && !isExtensible(a)) {
+ if (!this._f) this._f = new InternalMap();
+ var result = this._f[key](a, b);
+ return key == 'set' ? this : result;
+ // store all the rest on native weakmap
+ } return method.call(this, a, b);
+ });
+ });
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-set.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-set.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var weak = __webpack_require__(/*! ./_collection-weak */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-weak.js");
+var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_validate-collection.js");
+var WEAK_SET = 'WeakSet';
+
+// 23.4 WeakSet Objects
+__webpack_require__(/*! ./_collection */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection.js")(WEAK_SET, function (get) {
+ return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+}, {
+ // 23.4.3.1 WeakSet.prototype.add(value)
+ add: function add(value) {
+ return weak.def(validate(this, WEAK_SET), value, true);
+ }
+}, weak, false, true);
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.flat-map.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.flat-map.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var flattenIntoArray = __webpack_require__(/*! ./_flatten-into-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flatten-into-array.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var arraySpeciesCreate = __webpack_require__(/*! ./_array-species-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-create.js");
+
+$export($export.P, 'Array', {
+ flatMap: function flatMap(callbackfn /* , thisArg */) {
+ var O = toObject(this);
+ var sourceLen, A;
+ aFunction(callbackfn);
+ sourceLen = toLength(O.length);
+ A = arraySpeciesCreate(O, 0);
+ flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]);
+ return A;
+ }
+});
+
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")('flatMap');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.flatten.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.flatten.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatten
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var flattenIntoArray = __webpack_require__(/*! ./_flatten-into-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flatten-into-array.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-integer.js");
+var arraySpeciesCreate = __webpack_require__(/*! ./_array-species-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-species-create.js");
+
+$export($export.P, 'Array', {
+ flatten: function flatten(/* depthArg = 1 */) {
+ var depthArg = arguments[0];
+ var O = toObject(this);
+ var sourceLen = toLength(O.length);
+ var A = arraySpeciesCreate(O, 0);
+ flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));
+ return A;
+ }
+});
+
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")('flatten');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.includes.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.includes.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/tc39/Array.prototype.includes
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $includes = __webpack_require__(/*! ./_array-includes */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-includes.js")(true);
+
+$export($export.P, 'Array', {
+ includes: function includes(el /* , fromIndex = 0 */) {
+ return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+
+__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_add-to-unscopables.js")('includes');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.asap.js":
+/*!******************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.asap.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var microtask = __webpack_require__(/*! ./_microtask */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_microtask.js")();
+var process = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js").process;
+var isNode = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js")(process) == 'process';
+
+$export($export.G, {
+ asap: function asap(fn) {
+ var domain = isNode && process.domain;
+ microtask(domain ? domain.bind(fn) : fn);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.error.is-error.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.error.is-error.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/ljharb/proposal-is-error
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var cof = __webpack_require__(/*! ./_cof */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_cof.js");
+
+$export($export.S, 'Error', {
+ isError: function isError(it) {
+ return cof(it) === 'Error';
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.global.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.global.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/tc39/proposal-global
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.G, { global: __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.from.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.from.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from
+__webpack_require__(/*! ./_set-collection-from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-from.js")('Map');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.of.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.of.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of
+__webpack_require__(/*! ./_set-collection-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-of.js")('Map');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.to-json.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.to-json.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/DavidBruant/Map-Set.prototype.toJSON
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.P + $export.R, 'Map', { toJSON: __webpack_require__(/*! ./_collection-to-json */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-to-json.js")('Map') });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.clamp.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.clamp.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ clamp: function clamp(x, lower, upper) {
+ return Math.min(upper, Math.max(lower, x));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.deg-per-rad.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.deg-per-rad.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { DEG_PER_RAD: Math.PI / 180 });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.degrees.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.degrees.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var RAD_PER_DEG = 180 / Math.PI;
+
+$export($export.S, 'Math', {
+ degrees: function degrees(radians) {
+ return radians * RAD_PER_DEG;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.fscale.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.fscale.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var scale = __webpack_require__(/*! ./_math-scale */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-scale.js");
+var fround = __webpack_require__(/*! ./_math-fround */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-fround.js");
+
+$export($export.S, 'Math', {
+ fscale: function fscale(x, inLow, inHigh, outLow, outHigh) {
+ return fround(scale(x, inLow, inHigh, outLow, outHigh));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.iaddh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.iaddh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ iaddh: function iaddh(x0, x1, y0, y1) {
+ var $x0 = x0 >>> 0;
+ var $x1 = x1 >>> 0;
+ var $y0 = y0 >>> 0;
+ return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.imulh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.imulh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ imulh: function imulh(u, v) {
+ var UINT16 = 0xffff;
+ var $u = +u;
+ var $v = +v;
+ var u0 = $u & UINT16;
+ var v0 = $v & UINT16;
+ var u1 = $u >> 16;
+ var v1 = $v >> 16;
+ var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
+ return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.isubh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.isubh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ isubh: function isubh(x0, x1, y0, y1) {
+ var $x0 = x0 >>> 0;
+ var $x1 = x1 >>> 0;
+ var $y0 = y0 >>> 0;
+ return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.rad-per-deg.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.rad-per-deg.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { RAD_PER_DEG: 180 / Math.PI });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.radians.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.radians.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var DEG_PER_RAD = Math.PI / 180;
+
+$export($export.S, 'Math', {
+ radians: function radians(degrees) {
+ return degrees * DEG_PER_RAD;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.scale.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.scale.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://rwaldron.github.io/proposal-math-extensions/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { scale: __webpack_require__(/*! ./_math-scale */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_math-scale.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.signbit.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.signbit.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// http://jfbastien.github.io/papers/Math.signbit.html
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', { signbit: function signbit(x) {
+ // eslint-disable-next-line no-self-compare
+ return (x = +x) != x ? x : x == 0 ? 1 / x == Infinity : x > 0;
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.umulh.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.umulh.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'Math', {
+ umulh: function umulh(u, v) {
+ var UINT16 = 0xffff;
+ var $u = +u;
+ var $v = +v;
+ var u0 = $u & UINT16;
+ var v0 = $v & UINT16;
+ var u1 = $u >>> 16;
+ var v1 = $v >>> 16;
+ var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
+ return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.define-getter.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.define-getter.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var $defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+
+// B.2.2.2 Object.prototype.__defineGetter__(P, getter)
+__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
+ __defineGetter__: function __defineGetter__(P, getter) {
+ $defineProperty.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true });
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.define-setter.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.define-setter.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var $defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-dp.js");
+
+// B.2.2.3 Object.prototype.__defineSetter__(P, setter)
+__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
+ __defineSetter__: function __defineSetter__(P, setter) {
+ $defineProperty.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true });
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.entries.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.entries.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/tc39/proposal-object-values-entries
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $entries = __webpack_require__(/*! ./_object-to-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-to-array.js")(true);
+
+$export($export.S, 'Object', {
+ entries: function entries(it) {
+ return $entries(it);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.get-own-property-descriptors.js":
+/*!*************************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.get-own-property-descriptors.js ***!
+ \*************************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/tc39/proposal-object-getownpropertydescriptors
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var ownKeys = __webpack_require__(/*! ./_own-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_own-keys.js");
+var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-iobject.js");
+var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js");
+var createProperty = __webpack_require__(/*! ./_create-property */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_create-property.js");
+
+$export($export.S, 'Object', {
+ getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
+ var O = toIObject(object);
+ var getDesc = gOPD.f;
+ var keys = ownKeys(O);
+ var result = {};
+ var i = 0;
+ var key, desc;
+ while (keys.length > i) {
+ desc = getDesc(O, key = keys[i++]);
+ if (desc !== undefined) createProperty(result, key, desc);
+ }
+ return result;
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.lookup-getter.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.lookup-getter.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var getOwnPropertyDescriptor = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js").f;
+
+// B.2.2.4 Object.prototype.__lookupGetter__(P)
+__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
+ __lookupGetter__: function __lookupGetter__(P) {
+ var O = toObject(this);
+ var K = toPrimitive(P, true);
+ var D;
+ do {
+ if (D = getOwnPropertyDescriptor(O, K)) return D.get;
+ } while (O = getPrototypeOf(O));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.lookup-setter.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.lookup-setter.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-object.js");
+var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-primitive.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var getOwnPropertyDescriptor = __webpack_require__(/*! ./_object-gopd */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gopd.js").f;
+
+// B.2.2.5 Object.prototype.__lookupSetter__(P)
+__webpack_require__(/*! ./_descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
+ __lookupSetter__: function __lookupSetter__(P) {
+ var O = toObject(this);
+ var K = toPrimitive(P, true);
+ var D;
+ do {
+ if (D = getOwnPropertyDescriptor(O, K)) return D.set;
+ } while (O = getPrototypeOf(O));
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.values.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.values.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/tc39/proposal-object-values-entries
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $values = __webpack_require__(/*! ./_object-to-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-to-array.js")(false);
+
+$export($export.S, 'Object', {
+ values: function values(it) {
+ return $values(it);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.observable.js":
+/*!************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.observable.js ***!
+ \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/zenparsing/es-observable
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var core = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+var microtask = __webpack_require__(/*! ./_microtask */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_microtask.js")();
+var OBSERVABLE = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js")('observable');
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-instance.js");
+var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine-all.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_for-of.js");
+var RETURN = forOf.RETURN;
+
+var getMethod = function (fn) {
+ return fn == null ? undefined : aFunction(fn);
+};
+
+var cleanupSubscription = function (subscription) {
+ var cleanup = subscription._c;
+ if (cleanup) {
+ subscription._c = undefined;
+ cleanup();
+ }
+};
+
+var subscriptionClosed = function (subscription) {
+ return subscription._o === undefined;
+};
+
+var closeSubscription = function (subscription) {
+ if (!subscriptionClosed(subscription)) {
+ subscription._o = undefined;
+ cleanupSubscription(subscription);
+ }
+};
+
+var Subscription = function (observer, subscriber) {
+ anObject(observer);
+ this._c = undefined;
+ this._o = observer;
+ observer = new SubscriptionObserver(this);
+ try {
+ var cleanup = subscriber(observer);
+ var subscription = cleanup;
+ if (cleanup != null) {
+ if (typeof cleanup.unsubscribe === 'function') cleanup = function () { subscription.unsubscribe(); };
+ else aFunction(cleanup);
+ this._c = cleanup;
+ }
+ } catch (e) {
+ observer.error(e);
+ return;
+ } if (subscriptionClosed(this)) cleanupSubscription(this);
+};
+
+Subscription.prototype = redefineAll({}, {
+ unsubscribe: function unsubscribe() { closeSubscription(this); }
+});
+
+var SubscriptionObserver = function (subscription) {
+ this._s = subscription;
+};
+
+SubscriptionObserver.prototype = redefineAll({}, {
+ next: function next(value) {
+ var subscription = this._s;
+ if (!subscriptionClosed(subscription)) {
+ var observer = subscription._o;
+ try {
+ var m = getMethod(observer.next);
+ if (m) return m.call(observer, value);
+ } catch (e) {
+ try {
+ closeSubscription(subscription);
+ } finally {
+ throw e;
+ }
+ }
+ }
+ },
+ error: function error(value) {
+ var subscription = this._s;
+ if (subscriptionClosed(subscription)) throw value;
+ var observer = subscription._o;
+ subscription._o = undefined;
+ try {
+ var m = getMethod(observer.error);
+ if (!m) throw value;
+ value = m.call(observer, value);
+ } catch (e) {
+ try {
+ cleanupSubscription(subscription);
+ } finally {
+ throw e;
+ }
+ } cleanupSubscription(subscription);
+ return value;
+ },
+ complete: function complete(value) {
+ var subscription = this._s;
+ if (!subscriptionClosed(subscription)) {
+ var observer = subscription._o;
+ subscription._o = undefined;
+ try {
+ var m = getMethod(observer.complete);
+ value = m ? m.call(observer, value) : undefined;
+ } catch (e) {
+ try {
+ cleanupSubscription(subscription);
+ } finally {
+ throw e;
+ }
+ } cleanupSubscription(subscription);
+ return value;
+ }
+ }
+});
+
+var $Observable = function Observable(subscriber) {
+ anInstance(this, $Observable, 'Observable', '_f')._f = aFunction(subscriber);
+};
+
+redefineAll($Observable.prototype, {
+ subscribe: function subscribe(observer) {
+ return new Subscription(observer, this._f);
+ },
+ forEach: function forEach(fn) {
+ var that = this;
+ return new (core.Promise || global.Promise)(function (resolve, reject) {
+ aFunction(fn);
+ var subscription = that.subscribe({
+ next: function (value) {
+ try {
+ return fn(value);
+ } catch (e) {
+ reject(e);
+ subscription.unsubscribe();
+ }
+ },
+ error: reject,
+ complete: resolve
+ });
+ });
+ }
+});
+
+redefineAll($Observable, {
+ from: function from(x) {
+ var C = typeof this === 'function' ? this : $Observable;
+ var method = getMethod(anObject(x)[OBSERVABLE]);
+ if (method) {
+ var observable = anObject(method.call(x));
+ return observable.constructor === C ? observable : new C(function (observer) {
+ return observable.subscribe(observer);
+ });
+ }
+ return new C(function (observer) {
+ var done = false;
+ microtask(function () {
+ if (!done) {
+ try {
+ if (forOf(x, false, function (it) {
+ observer.next(it);
+ if (done) return RETURN;
+ }) === RETURN) return;
+ } catch (e) {
+ if (done) throw e;
+ observer.error(e);
+ return;
+ } observer.complete();
+ }
+ });
+ return function () { done = true; };
+ });
+ },
+ of: function of() {
+ for (var i = 0, l = arguments.length, items = new Array(l); i < l;) items[i] = arguments[i++];
+ return new (typeof this === 'function' ? this : $Observable)(function (observer) {
+ var done = false;
+ microtask(function () {
+ if (!done) {
+ for (var j = 0; j < items.length; ++j) {
+ observer.next(items[j]);
+ if (done) return;
+ } observer.complete();
+ }
+ });
+ return function () { done = true; };
+ });
+ }
+});
+
+hide($Observable.prototype, OBSERVABLE, function () { return this; });
+
+$export($export.G, { Observable: $Observable });
+
+__webpack_require__(/*! ./_set-species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-species.js")('Observable');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.promise.finally.js":
+/*!*****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.promise.finally.js ***!
+ \*****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// https://github.com/tc39/proposal-promise-finally
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var core = __webpack_require__(/*! ./_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_species-constructor.js");
+var promiseResolve = __webpack_require__(/*! ./_promise-resolve */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_promise-resolve.js");
+
+$export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {
+ var C = speciesConstructor(this, core.Promise || global.Promise);
+ var isFunction = typeof onFinally == 'function';
+ return this.then(
+ isFunction ? function (x) {
+ return promiseResolve(C, onFinally()).then(function () { return x; });
+ } : onFinally,
+ isFunction ? function (e) {
+ return promiseResolve(C, onFinally()).then(function () { throw e; });
+ } : onFinally
+ );
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.promise.try.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.promise.try.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/tc39/proposal-promise-try
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var newPromiseCapability = __webpack_require__(/*! ./_new-promise-capability */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_new-promise-capability.js");
+var perform = __webpack_require__(/*! ./_perform */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_perform.js");
+
+$export($export.S, 'Promise', { 'try': function (callbackfn) {
+ var promiseCapability = newPromiseCapability.f(this);
+ var result = perform(callbackfn);
+ (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
+ return promiseCapability.promise;
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.define-metadata.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.define-metadata.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toMetaKey = metadata.key;
+var ordinaryDefineOwnMetadata = metadata.set;
+
+metadata.exp({ defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey) {
+ ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetaKey(targetKey));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.delete-metadata.js":
+/*!*************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.delete-metadata.js ***!
+ \*************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var toMetaKey = metadata.key;
+var getOrCreateMetadataMap = metadata.map;
+var store = metadata.store;
+
+metadata.exp({ deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) {
+ var targetKey = arguments.length < 3 ? undefined : toMetaKey(arguments[2]);
+ var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false);
+ if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false;
+ if (metadataMap.size) return true;
+ var targetMetadata = store.get(target);
+ targetMetadata['delete'](targetKey);
+ return !!targetMetadata.size || store['delete'](target);
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-metadata-keys.js":
+/*!***************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-metadata-keys.js ***!
+ \***************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var Set = __webpack_require__(/*! ./es6.set */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.set.js");
+var from = __webpack_require__(/*! ./_array-from-iterable */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_array-from-iterable.js");
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var ordinaryOwnMetadataKeys = metadata.keys;
+var toMetaKey = metadata.key;
+
+var ordinaryMetadataKeys = function (O, P) {
+ var oKeys = ordinaryOwnMetadataKeys(O, P);
+ var parent = getPrototypeOf(O);
+ if (parent === null) return oKeys;
+ var pKeys = ordinaryMetadataKeys(parent, P);
+ return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys;
+};
+
+metadata.exp({ getMetadataKeys: function getMetadataKeys(target /* , targetKey */) {
+ return ordinaryMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-metadata.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-metadata.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var ordinaryHasOwnMetadata = metadata.has;
+var ordinaryGetOwnMetadata = metadata.get;
+var toMetaKey = metadata.key;
+
+var ordinaryGetMetadata = function (MetadataKey, O, P) {
+ var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
+ if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P);
+ var parent = getPrototypeOf(O);
+ return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined;
+};
+
+metadata.exp({ getMetadata: function getMetadata(metadataKey, target /* , targetKey */) {
+ return ordinaryGetMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js":
+/*!*******************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js ***!
+ \*******************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var ordinaryOwnMetadataKeys = metadata.keys;
+var toMetaKey = metadata.key;
+
+metadata.exp({ getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) {
+ return ordinaryOwnMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-own-metadata.js":
+/*!**************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-own-metadata.js ***!
+ \**************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var ordinaryGetOwnMetadata = metadata.get;
+var toMetaKey = metadata.key;
+
+metadata.exp({ getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) {
+ return ordinaryGetOwnMetadata(metadataKey, anObject(target)
+ , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.has-metadata.js":
+/*!**********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.has-metadata.js ***!
+ \**********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-gpo.js");
+var ordinaryHasOwnMetadata = metadata.has;
+var toMetaKey = metadata.key;
+
+var ordinaryHasMetadata = function (MetadataKey, O, P) {
+ var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
+ if (hasOwn) return true;
+ var parent = getPrototypeOf(O);
+ return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false;
+};
+
+metadata.exp({ hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) {
+ return ordinaryHasMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.has-own-metadata.js":
+/*!**************************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.has-own-metadata.js ***!
+ \**************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var ordinaryHasOwnMetadata = metadata.has;
+var toMetaKey = metadata.key;
+
+metadata.exp({ hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) {
+ return ordinaryHasOwnMetadata(metadataKey, anObject(target)
+ , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.metadata.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.metadata.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_metadata.js");
+var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_an-object.js");
+var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_a-function.js");
+var toMetaKey = $metadata.key;
+var ordinaryDefineOwnMetadata = $metadata.set;
+
+$metadata.exp({ metadata: function metadata(metadataKey, metadataValue) {
+ return function decorator(target, targetKey) {
+ ordinaryDefineOwnMetadata(
+ metadataKey, metadataValue,
+ (targetKey !== undefined ? anObject : aFunction)(target),
+ toMetaKey(targetKey)
+ );
+ };
+} });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.from.js":
+/*!**********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.from.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from
+__webpack_require__(/*! ./_set-collection-from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-from.js")('Set');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.of.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.of.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of
+__webpack_require__(/*! ./_set-collection-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-of.js")('Set');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.to-json.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.to-json.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/DavidBruant/Map-Set.prototype.toJSON
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.P + $export.R, 'Set', { toJSON: __webpack_require__(/*! ./_collection-to-json */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_collection-to-json.js")('Set') });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.at.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.at.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/mathiasbynens/String.prototype.at
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $at = __webpack_require__(/*! ./_string-at */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-at.js")(true);
+
+$export($export.P, 'String', {
+ at: function at(pos) {
+ return $at(this, pos);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.match-all.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.match-all.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://tc39.github.io/String.prototype.matchAll/
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var defined = __webpack_require__(/*! ./_defined */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_defined.js");
+var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_to-length.js");
+var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_is-regexp.js");
+var getFlags = __webpack_require__(/*! ./_flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_flags.js");
+var RegExpProto = RegExp.prototype;
+
+var $RegExpStringIterator = function (regexp, string) {
+ this._r = regexp;
+ this._s = string;
+};
+
+__webpack_require__(/*! ./_iter-create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iter-create.js")($RegExpStringIterator, 'RegExp String', function next() {
+ var match = this._r.exec(this._s);
+ return { value: match, done: match === null };
+});
+
+$export($export.P, 'String', {
+ matchAll: function matchAll(regexp) {
+ defined(this);
+ if (!isRegExp(regexp)) throw TypeError(regexp + ' is not a regexp!');
+ var S = String(this);
+ var flags = 'flags' in RegExpProto ? String(regexp.flags) : getFlags.call(regexp);
+ var rx = new RegExp(regexp.source, ~flags.indexOf('g') ? flags : 'g' + flags);
+ rx.lastIndex = toLength(regexp.lastIndex);
+ return new $RegExpStringIterator(rx, S);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.pad-end.js":
+/*!****************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.pad-end.js ***!
+ \****************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/tc39/proposal-string-pad-start-end
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $pad = __webpack_require__(/*! ./_string-pad */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-pad.js");
+var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_user-agent.js");
+
+// https://github.com/zloirock/core-js/issues/280
+var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
+
+$export($export.P + $export.F * WEBKIT_BUG, 'String', {
+ padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
+ return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.pad-start.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.pad-start.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/tc39/proposal-string-pad-start-end
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $pad = __webpack_require__(/*! ./_string-pad */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-pad.js");
+var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_user-agent.js");
+
+// https://github.com/zloirock/core-js/issues/280
+var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
+
+$export($export.P + $export.F * WEBKIT_BUG, 'String', {
+ padStart: function padStart(maxLength /* , fillString = ' ' */) {
+ return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
+ }
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.trim-left.js":
+/*!******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.trim-left.js ***!
+ \******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/sebmarkbage/ecmascript-string-left-right-trim
+__webpack_require__(/*! ./_string-trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js")('trimLeft', function ($trim) {
+ return function trimLeft() {
+ return $trim(this, 1);
+ };
+}, 'trimStart');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.trim-right.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.trim-right.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// https://github.com/sebmarkbage/ecmascript-string-left-right-trim
+__webpack_require__(/*! ./_string-trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_string-trim.js")('trimRight', function ($trim) {
+ return function trimRight() {
+ return $trim(this, 2);
+ };
+}, 'trimEnd');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.symbol.async-iterator.js":
+/*!***********************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.symbol.async-iterator.js ***!
+ \***********************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_wks-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-define.js")('asyncIterator');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.symbol.observable.js":
+/*!*******************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.symbol.observable.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./_wks-define */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks-define.js")('observable');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.system.global.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.system.global.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://github.com/tc39/proposal-global
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+
+$export($export.S, 'System', { global: __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js") });
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-map.from.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-map.from.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from
+__webpack_require__(/*! ./_set-collection-from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-from.js")('WeakMap');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-map.of.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-map.of.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
+__webpack_require__(/*! ./_set-collection-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-of.js")('WeakMap');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-set.from.js":
+/*!***************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-set.from.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from
+__webpack_require__(/*! ./_set-collection-from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-from.js")('WeakSet');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-set.of.js":
+/*!*************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-set.of.js ***!
+ \*************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of
+__webpack_require__(/*! ./_set-collection-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_set-collection-of.js")('WeakSet');
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/web.dom.iterable.js":
+/*!**************************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/web.dom.iterable.js ***!
+ \**************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $iterators = __webpack_require__(/*! ./es6.array.iterator */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.iterator.js");
+var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_object-keys.js");
+var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_redefine.js");
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var hide = __webpack_require__(/*! ./_hide */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_hide.js");
+var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_iterators.js");
+var wks = __webpack_require__(/*! ./_wks */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_wks.js");
+var ITERATOR = wks('iterator');
+var TO_STRING_TAG = wks('toStringTag');
+var ArrayValues = Iterators.Array;
+
+var DOMIterables = {
+ CSSRuleList: true, // TODO: Not spec compliant, should be false.
+ CSSStyleDeclaration: false,
+ CSSValueList: false,
+ ClientRectList: false,
+ DOMRectList: false,
+ DOMStringList: false,
+ DOMTokenList: true,
+ DataTransferItemList: false,
+ FileList: false,
+ HTMLAllCollection: false,
+ HTMLCollection: false,
+ HTMLFormElement: false,
+ HTMLSelectElement: false,
+ MediaList: true, // TODO: Not spec compliant, should be false.
+ MimeTypeArray: false,
+ NamedNodeMap: false,
+ NodeList: true,
+ PaintRequestList: false,
+ Plugin: false,
+ PluginArray: false,
+ SVGLengthList: false,
+ SVGNumberList: false,
+ SVGPathSegList: false,
+ SVGPointList: false,
+ SVGStringList: false,
+ SVGTransformList: false,
+ SourceBufferList: false,
+ StyleSheetList: true, // TODO: Not spec compliant, should be false.
+ TextTrackCueList: false,
+ TextTrackList: false,
+ TouchList: false
+};
+
+for (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) {
+ var NAME = collections[i];
+ var explicit = DOMIterables[NAME];
+ var Collection = global[NAME];
+ var proto = Collection && Collection.prototype;
+ var key;
+ if (proto) {
+ if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);
+ if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
+ Iterators[NAME] = ArrayValues;
+ if (explicit) for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true);
+ }
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/web.immediate.js":
+/*!***********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/web.immediate.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var $task = __webpack_require__(/*! ./_task */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_task.js");
+$export($export.G + $export.B, {
+ setImmediate: $task.set,
+ clearImmediate: $task.clear
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/modules/web.timers.js":
+/*!********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/modules/web.timers.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+// ie9- setTimeout & setInterval additional parameters fix
+var global = __webpack_require__(/*! ./_global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_global.js");
+var $export = __webpack_require__(/*! ./_export */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_export.js");
+var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_user-agent.js");
+var slice = [].slice;
+var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check
+var wrap = function (set) {
+ return function (fn, time /* , ...args */) {
+ var boundArgs = arguments.length > 2;
+ var args = boundArgs ? slice.call(arguments, 2) : false;
+ return set(boundArgs ? function () {
+ // eslint-disable-next-line no-new-func
+ (typeof fn == 'function' ? fn : Function(fn)).apply(this, args);
+ } : fn, time);
+ };
+};
+$export($export.G + $export.B + $export.F * MSIE, {
+ setTimeout: wrap(global.setTimeout),
+ setInterval: wrap(global.setInterval)
+});
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/core-js/shim.js":
+/*!******************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/core-js/shim.js ***!
+ \******************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(/*! ./modules/es6.symbol */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.symbol.js");
+__webpack_require__(/*! ./modules/es6.object.create */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.create.js");
+__webpack_require__(/*! ./modules/es6.object.define-property */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.define-property.js");
+__webpack_require__(/*! ./modules/es6.object.define-properties */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.define-properties.js");
+__webpack_require__(/*! ./modules/es6.object.get-own-property-descriptor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-own-property-descriptor.js");
+__webpack_require__(/*! ./modules/es6.object.get-prototype-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-prototype-of.js");
+__webpack_require__(/*! ./modules/es6.object.keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.keys.js");
+__webpack_require__(/*! ./modules/es6.object.get-own-property-names */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.get-own-property-names.js");
+__webpack_require__(/*! ./modules/es6.object.freeze */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.freeze.js");
+__webpack_require__(/*! ./modules/es6.object.seal */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.seal.js");
+__webpack_require__(/*! ./modules/es6.object.prevent-extensions */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.prevent-extensions.js");
+__webpack_require__(/*! ./modules/es6.object.is-frozen */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-frozen.js");
+__webpack_require__(/*! ./modules/es6.object.is-sealed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-sealed.js");
+__webpack_require__(/*! ./modules/es6.object.is-extensible */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is-extensible.js");
+__webpack_require__(/*! ./modules/es6.object.assign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.assign.js");
+__webpack_require__(/*! ./modules/es6.object.is */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.is.js");
+__webpack_require__(/*! ./modules/es6.object.set-prototype-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.set-prototype-of.js");
+__webpack_require__(/*! ./modules/es6.object.to-string */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.object.to-string.js");
+__webpack_require__(/*! ./modules/es6.function.bind */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.bind.js");
+__webpack_require__(/*! ./modules/es6.function.name */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.name.js");
+__webpack_require__(/*! ./modules/es6.function.has-instance */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.function.has-instance.js");
+__webpack_require__(/*! ./modules/es6.parse-int */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.parse-int.js");
+__webpack_require__(/*! ./modules/es6.parse-float */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.parse-float.js");
+__webpack_require__(/*! ./modules/es6.number.constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.constructor.js");
+__webpack_require__(/*! ./modules/es6.number.to-fixed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.to-fixed.js");
+__webpack_require__(/*! ./modules/es6.number.to-precision */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.to-precision.js");
+__webpack_require__(/*! ./modules/es6.number.epsilon */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.epsilon.js");
+__webpack_require__(/*! ./modules/es6.number.is-finite */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-finite.js");
+__webpack_require__(/*! ./modules/es6.number.is-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-integer.js");
+__webpack_require__(/*! ./modules/es6.number.is-nan */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-nan.js");
+__webpack_require__(/*! ./modules/es6.number.is-safe-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.is-safe-integer.js");
+__webpack_require__(/*! ./modules/es6.number.max-safe-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.max-safe-integer.js");
+__webpack_require__(/*! ./modules/es6.number.min-safe-integer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.min-safe-integer.js");
+__webpack_require__(/*! ./modules/es6.number.parse-float */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.parse-float.js");
+__webpack_require__(/*! ./modules/es6.number.parse-int */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.number.parse-int.js");
+__webpack_require__(/*! ./modules/es6.math.acosh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.acosh.js");
+__webpack_require__(/*! ./modules/es6.math.asinh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.asinh.js");
+__webpack_require__(/*! ./modules/es6.math.atanh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.atanh.js");
+__webpack_require__(/*! ./modules/es6.math.cbrt */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.cbrt.js");
+__webpack_require__(/*! ./modules/es6.math.clz32 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.clz32.js");
+__webpack_require__(/*! ./modules/es6.math.cosh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.cosh.js");
+__webpack_require__(/*! ./modules/es6.math.expm1 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.expm1.js");
+__webpack_require__(/*! ./modules/es6.math.fround */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.fround.js");
+__webpack_require__(/*! ./modules/es6.math.hypot */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.hypot.js");
+__webpack_require__(/*! ./modules/es6.math.imul */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.imul.js");
+__webpack_require__(/*! ./modules/es6.math.log10 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log10.js");
+__webpack_require__(/*! ./modules/es6.math.log1p */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log1p.js");
+__webpack_require__(/*! ./modules/es6.math.log2 */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.log2.js");
+__webpack_require__(/*! ./modules/es6.math.sign */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.sign.js");
+__webpack_require__(/*! ./modules/es6.math.sinh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.sinh.js");
+__webpack_require__(/*! ./modules/es6.math.tanh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.tanh.js");
+__webpack_require__(/*! ./modules/es6.math.trunc */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.math.trunc.js");
+__webpack_require__(/*! ./modules/es6.string.from-code-point */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.from-code-point.js");
+__webpack_require__(/*! ./modules/es6.string.raw */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.raw.js");
+__webpack_require__(/*! ./modules/es6.string.trim */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.trim.js");
+__webpack_require__(/*! ./modules/es6.string.iterator */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.iterator.js");
+__webpack_require__(/*! ./modules/es6.string.code-point-at */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.code-point-at.js");
+__webpack_require__(/*! ./modules/es6.string.ends-with */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.ends-with.js");
+__webpack_require__(/*! ./modules/es6.string.includes */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.includes.js");
+__webpack_require__(/*! ./modules/es6.string.repeat */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.repeat.js");
+__webpack_require__(/*! ./modules/es6.string.starts-with */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.starts-with.js");
+__webpack_require__(/*! ./modules/es6.string.anchor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.anchor.js");
+__webpack_require__(/*! ./modules/es6.string.big */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.big.js");
+__webpack_require__(/*! ./modules/es6.string.blink */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.blink.js");
+__webpack_require__(/*! ./modules/es6.string.bold */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.bold.js");
+__webpack_require__(/*! ./modules/es6.string.fixed */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fixed.js");
+__webpack_require__(/*! ./modules/es6.string.fontcolor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fontcolor.js");
+__webpack_require__(/*! ./modules/es6.string.fontsize */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.fontsize.js");
+__webpack_require__(/*! ./modules/es6.string.italics */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.italics.js");
+__webpack_require__(/*! ./modules/es6.string.link */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.link.js");
+__webpack_require__(/*! ./modules/es6.string.small */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.small.js");
+__webpack_require__(/*! ./modules/es6.string.strike */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.strike.js");
+__webpack_require__(/*! ./modules/es6.string.sub */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.sub.js");
+__webpack_require__(/*! ./modules/es6.string.sup */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.string.sup.js");
+__webpack_require__(/*! ./modules/es6.date.now */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.now.js");
+__webpack_require__(/*! ./modules/es6.date.to-json */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-json.js");
+__webpack_require__(/*! ./modules/es6.date.to-iso-string */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-iso-string.js");
+__webpack_require__(/*! ./modules/es6.date.to-string */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-string.js");
+__webpack_require__(/*! ./modules/es6.date.to-primitive */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.date.to-primitive.js");
+__webpack_require__(/*! ./modules/es6.array.is-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.is-array.js");
+__webpack_require__(/*! ./modules/es6.array.from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.from.js");
+__webpack_require__(/*! ./modules/es6.array.of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.of.js");
+__webpack_require__(/*! ./modules/es6.array.join */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.join.js");
+__webpack_require__(/*! ./modules/es6.array.slice */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.slice.js");
+__webpack_require__(/*! ./modules/es6.array.sort */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.sort.js");
+__webpack_require__(/*! ./modules/es6.array.for-each */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.for-each.js");
+__webpack_require__(/*! ./modules/es6.array.map */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.map.js");
+__webpack_require__(/*! ./modules/es6.array.filter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.filter.js");
+__webpack_require__(/*! ./modules/es6.array.some */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.some.js");
+__webpack_require__(/*! ./modules/es6.array.every */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.every.js");
+__webpack_require__(/*! ./modules/es6.array.reduce */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.reduce.js");
+__webpack_require__(/*! ./modules/es6.array.reduce-right */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.reduce-right.js");
+__webpack_require__(/*! ./modules/es6.array.index-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.index-of.js");
+__webpack_require__(/*! ./modules/es6.array.last-index-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.last-index-of.js");
+__webpack_require__(/*! ./modules/es6.array.copy-within */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.copy-within.js");
+__webpack_require__(/*! ./modules/es6.array.fill */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.fill.js");
+__webpack_require__(/*! ./modules/es6.array.find */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.find.js");
+__webpack_require__(/*! ./modules/es6.array.find-index */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.find-index.js");
+__webpack_require__(/*! ./modules/es6.array.species */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.species.js");
+__webpack_require__(/*! ./modules/es6.array.iterator */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.array.iterator.js");
+__webpack_require__(/*! ./modules/es6.regexp.constructor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.constructor.js");
+__webpack_require__(/*! ./modules/es6.regexp.exec */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.exec.js");
+__webpack_require__(/*! ./modules/es6.regexp.to-string */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.to-string.js");
+__webpack_require__(/*! ./modules/es6.regexp.flags */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.flags.js");
+__webpack_require__(/*! ./modules/es6.regexp.match */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.match.js");
+__webpack_require__(/*! ./modules/es6.regexp.replace */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.replace.js");
+__webpack_require__(/*! ./modules/es6.regexp.search */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.search.js");
+__webpack_require__(/*! ./modules/es6.regexp.split */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.regexp.split.js");
+__webpack_require__(/*! ./modules/es6.promise */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.promise.js");
+__webpack_require__(/*! ./modules/es6.map */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.map.js");
+__webpack_require__(/*! ./modules/es6.set */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.set.js");
+__webpack_require__(/*! ./modules/es6.weak-map */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-map.js");
+__webpack_require__(/*! ./modules/es6.weak-set */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.weak-set.js");
+__webpack_require__(/*! ./modules/es6.typed.array-buffer */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.array-buffer.js");
+__webpack_require__(/*! ./modules/es6.typed.data-view */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.data-view.js");
+__webpack_require__(/*! ./modules/es6.typed.int8-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int8-array.js");
+__webpack_require__(/*! ./modules/es6.typed.uint8-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint8-array.js");
+__webpack_require__(/*! ./modules/es6.typed.uint8-clamped-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint8-clamped-array.js");
+__webpack_require__(/*! ./modules/es6.typed.int16-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int16-array.js");
+__webpack_require__(/*! ./modules/es6.typed.uint16-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint16-array.js");
+__webpack_require__(/*! ./modules/es6.typed.int32-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.int32-array.js");
+__webpack_require__(/*! ./modules/es6.typed.uint32-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.uint32-array.js");
+__webpack_require__(/*! ./modules/es6.typed.float32-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.float32-array.js");
+__webpack_require__(/*! ./modules/es6.typed.float64-array */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.typed.float64-array.js");
+__webpack_require__(/*! ./modules/es6.reflect.apply */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.apply.js");
+__webpack_require__(/*! ./modules/es6.reflect.construct */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.construct.js");
+__webpack_require__(/*! ./modules/es6.reflect.define-property */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.define-property.js");
+__webpack_require__(/*! ./modules/es6.reflect.delete-property */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.delete-property.js");
+__webpack_require__(/*! ./modules/es6.reflect.enumerate */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.enumerate.js");
+__webpack_require__(/*! ./modules/es6.reflect.get */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get.js");
+__webpack_require__(/*! ./modules/es6.reflect.get-own-property-descriptor */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js");
+__webpack_require__(/*! ./modules/es6.reflect.get-prototype-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.get-prototype-of.js");
+__webpack_require__(/*! ./modules/es6.reflect.has */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.has.js");
+__webpack_require__(/*! ./modules/es6.reflect.is-extensible */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.is-extensible.js");
+__webpack_require__(/*! ./modules/es6.reflect.own-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.own-keys.js");
+__webpack_require__(/*! ./modules/es6.reflect.prevent-extensions */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.prevent-extensions.js");
+__webpack_require__(/*! ./modules/es6.reflect.set */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.set.js");
+__webpack_require__(/*! ./modules/es6.reflect.set-prototype-of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es6.reflect.set-prototype-of.js");
+__webpack_require__(/*! ./modules/es7.array.includes */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.includes.js");
+__webpack_require__(/*! ./modules/es7.array.flat-map */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.flat-map.js");
+__webpack_require__(/*! ./modules/es7.array.flatten */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.array.flatten.js");
+__webpack_require__(/*! ./modules/es7.string.at */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.at.js");
+__webpack_require__(/*! ./modules/es7.string.pad-start */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.pad-start.js");
+__webpack_require__(/*! ./modules/es7.string.pad-end */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.pad-end.js");
+__webpack_require__(/*! ./modules/es7.string.trim-left */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.trim-left.js");
+__webpack_require__(/*! ./modules/es7.string.trim-right */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.trim-right.js");
+__webpack_require__(/*! ./modules/es7.string.match-all */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.string.match-all.js");
+__webpack_require__(/*! ./modules/es7.symbol.async-iterator */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.symbol.async-iterator.js");
+__webpack_require__(/*! ./modules/es7.symbol.observable */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.symbol.observable.js");
+__webpack_require__(/*! ./modules/es7.object.get-own-property-descriptors */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.get-own-property-descriptors.js");
+__webpack_require__(/*! ./modules/es7.object.values */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.values.js");
+__webpack_require__(/*! ./modules/es7.object.entries */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.entries.js");
+__webpack_require__(/*! ./modules/es7.object.define-getter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.define-getter.js");
+__webpack_require__(/*! ./modules/es7.object.define-setter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.define-setter.js");
+__webpack_require__(/*! ./modules/es7.object.lookup-getter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.lookup-getter.js");
+__webpack_require__(/*! ./modules/es7.object.lookup-setter */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.object.lookup-setter.js");
+__webpack_require__(/*! ./modules/es7.map.to-json */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.to-json.js");
+__webpack_require__(/*! ./modules/es7.set.to-json */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.to-json.js");
+__webpack_require__(/*! ./modules/es7.map.of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.of.js");
+__webpack_require__(/*! ./modules/es7.set.of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.of.js");
+__webpack_require__(/*! ./modules/es7.weak-map.of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-map.of.js");
+__webpack_require__(/*! ./modules/es7.weak-set.of */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-set.of.js");
+__webpack_require__(/*! ./modules/es7.map.from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.map.from.js");
+__webpack_require__(/*! ./modules/es7.set.from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.set.from.js");
+__webpack_require__(/*! ./modules/es7.weak-map.from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-map.from.js");
+__webpack_require__(/*! ./modules/es7.weak-set.from */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.weak-set.from.js");
+__webpack_require__(/*! ./modules/es7.global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.global.js");
+__webpack_require__(/*! ./modules/es7.system.global */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.system.global.js");
+__webpack_require__(/*! ./modules/es7.error.is-error */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.error.is-error.js");
+__webpack_require__(/*! ./modules/es7.math.clamp */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.clamp.js");
+__webpack_require__(/*! ./modules/es7.math.deg-per-rad */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.deg-per-rad.js");
+__webpack_require__(/*! ./modules/es7.math.degrees */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.degrees.js");
+__webpack_require__(/*! ./modules/es7.math.fscale */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.fscale.js");
+__webpack_require__(/*! ./modules/es7.math.iaddh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.iaddh.js");
+__webpack_require__(/*! ./modules/es7.math.isubh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.isubh.js");
+__webpack_require__(/*! ./modules/es7.math.imulh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.imulh.js");
+__webpack_require__(/*! ./modules/es7.math.rad-per-deg */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.rad-per-deg.js");
+__webpack_require__(/*! ./modules/es7.math.radians */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.radians.js");
+__webpack_require__(/*! ./modules/es7.math.scale */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.scale.js");
+__webpack_require__(/*! ./modules/es7.math.umulh */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.umulh.js");
+__webpack_require__(/*! ./modules/es7.math.signbit */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.math.signbit.js");
+__webpack_require__(/*! ./modules/es7.promise.finally */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.promise.finally.js");
+__webpack_require__(/*! ./modules/es7.promise.try */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.promise.try.js");
+__webpack_require__(/*! ./modules/es7.reflect.define-metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.define-metadata.js");
+__webpack_require__(/*! ./modules/es7.reflect.delete-metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.delete-metadata.js");
+__webpack_require__(/*! ./modules/es7.reflect.get-metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-metadata.js");
+__webpack_require__(/*! ./modules/es7.reflect.get-metadata-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-metadata-keys.js");
+__webpack_require__(/*! ./modules/es7.reflect.get-own-metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-own-metadata.js");
+__webpack_require__(/*! ./modules/es7.reflect.get-own-metadata-keys */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js");
+__webpack_require__(/*! ./modules/es7.reflect.has-metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.has-metadata.js");
+__webpack_require__(/*! ./modules/es7.reflect.has-own-metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.has-own-metadata.js");
+__webpack_require__(/*! ./modules/es7.reflect.metadata */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.reflect.metadata.js");
+__webpack_require__(/*! ./modules/es7.asap */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.asap.js");
+__webpack_require__(/*! ./modules/es7.observable */ "./node_modules/babel-polyfill/node_modules/core-js/modules/es7.observable.js");
+__webpack_require__(/*! ./modules/web.timers */ "./node_modules/babel-polyfill/node_modules/core-js/modules/web.timers.js");
+__webpack_require__(/*! ./modules/web.immediate */ "./node_modules/babel-polyfill/node_modules/core-js/modules/web.immediate.js");
+__webpack_require__(/*! ./modules/web.dom.iterable */ "./node_modules/babel-polyfill/node_modules/core-js/modules/web.dom.iterable.js");
+module.exports = __webpack_require__(/*! ./modules/_core */ "./node_modules/babel-polyfill/node_modules/core-js/modules/_core.js");
+
+
+/***/ }),
+
+/***/ "./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js":
+/*!*********************************************************************************!*\
+ !*** ./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global) {/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+!(function(global) {
+ "use strict";
+
+ var Op = Object.prototype;
+ var hasOwn = Op.hasOwnProperty;
+ var undefined; // More compressible than void 0.
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+ var inModule = typeof module === "object";
+ var runtime = global.regeneratorRuntime;
+ if (runtime) {
+ if (inModule) {
+ // If regeneratorRuntime is defined globally and we're in a module,
+ // make the exports object identical to regeneratorRuntime.
+ module.exports = runtime;
+ }
+ // Don't bother evaluating the rest of this file if the runtime was
+ // already defined globally.
+ return;
+ }
+
+ // Define the runtime globally (as expected by generated code) as either
+ // module.exports (if we're in a module) or a new, empty object.
+ runtime = global.regeneratorRuntime = inModule ? module.exports : {};
+
+ function wrap(innerFn, outerFn, self, tryLocsList) {
+ // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+ var generator = Object.create(protoGenerator.prototype);
+ var context = new Context(tryLocsList || []);
+
+ // The ._invoke method unifies the implementations of the .next,
+ // .throw, and .return methods.
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
+
+ return generator;
+ }
+ runtime.wrap = wrap;
+
+ // Try/catch helper to minimize deoptimizations. Returns a completion
+ // record like context.tryEntries[i].completion. This interface could
+ // have been (and was previously) designed to take a closure to be
+ // invoked without arguments, but in all the cases we care about we
+ // already have an existing method we want to call, so there's no need
+ // to create a new function object. We can even get away with assuming
+ // the method takes exactly one argument, since that happens to be true
+ // in every case, so we don't have to touch the arguments object. The
+ // only additional allocation required is the completion record, which
+ // has a stable shape and so hopefully should be cheap to allocate.
+ function tryCatch(fn, obj, arg) {
+ try {
+ return { type: "normal", arg: fn.call(obj, arg) };
+ } catch (err) {
+ return { type: "throw", arg: err };
+ }
+ }
+
+ var GenStateSuspendedStart = "suspendedStart";
+ var GenStateSuspendedYield = "suspendedYield";
+ var GenStateExecuting = "executing";
+ var GenStateCompleted = "completed";
+
+ // Returning this object from the innerFn has the same effect as
+ // breaking out of the dispatch switch statement.
+ var ContinueSentinel = {};
+
+ // Dummy constructor functions that we use as the .constructor and
+ // .constructor.prototype properties for functions that return Generator
+ // objects. For full spec compliance, you may wish to configure your
+ // minifier not to mangle the names of these two functions.
+ function Generator() {}
+ function GeneratorFunction() {}
+ function GeneratorFunctionPrototype() {}
+
+ // This is a polyfill for %IteratorPrototype% for environments that
+ // don't natively support it.
+ var IteratorPrototype = {};
+ IteratorPrototype[iteratorSymbol] = function () {
+ return this;
+ };
+
+ var getProto = Object.getPrototypeOf;
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+ if (NativeIteratorPrototype &&
+ NativeIteratorPrototype !== Op &&
+ hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+ // This environment has a native %IteratorPrototype%; use it instead
+ // of the polyfill.
+ IteratorPrototype = NativeIteratorPrototype;
+ }
+
+ var Gp = GeneratorFunctionPrototype.prototype =
+ Generator.prototype = Object.create(IteratorPrototype);
+ GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+ GeneratorFunctionPrototype.constructor = GeneratorFunction;
+ GeneratorFunctionPrototype[toStringTagSymbol] =
+ GeneratorFunction.displayName = "GeneratorFunction";
+
+ // Helper for defining the .next, .throw, and .return methods of the
+ // Iterator interface in terms of a single ._invoke method.
+ function defineIteratorMethods(prototype) {
+ ["next", "throw", "return"].forEach(function(method) {
+ prototype[method] = function(arg) {
+ return this._invoke(method, arg);
+ };
+ });
+ }
+
+ runtime.isGeneratorFunction = function(genFun) {
+ var ctor = typeof genFun === "function" && genFun.constructor;
+ return ctor
+ ? ctor === GeneratorFunction ||
+ // For the native GeneratorFunction constructor, the best we can
+ // do is to check its .name property.
+ (ctor.displayName || ctor.name) === "GeneratorFunction"
+ : false;
+ };
+
+ runtime.mark = function(genFun) {
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+ } else {
+ genFun.__proto__ = GeneratorFunctionPrototype;
+ if (!(toStringTagSymbol in genFun)) {
+ genFun[toStringTagSymbol] = "GeneratorFunction";
+ }
+ }
+ genFun.prototype = Object.create(Gp);
+ return genFun;
+ };
+
+ // Within the body of any async function, `await x` is transformed to
+ // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+ // `hasOwn.call(value, "__await")` to determine if the yielded value is
+ // meant to be awaited.
+ runtime.awrap = function(arg) {
+ return { __await: arg };
+ };
+
+ function AsyncIterator(generator) {
+ function invoke(method, arg, resolve, reject) {
+ var record = tryCatch(generator[method], generator, arg);
+ if (record.type === "throw") {
+ reject(record.arg);
+ } else {
+ var result = record.arg;
+ var value = result.value;
+ if (value &&
+ typeof value === "object" &&
+ hasOwn.call(value, "__await")) {
+ return Promise.resolve(value.__await).then(function(value) {
+ invoke("next", value, resolve, reject);
+ }, function(err) {
+ invoke("throw", err, resolve, reject);
+ });
+ }
+
+ return Promise.resolve(value).then(function(unwrapped) {
+ // When a yielded Promise is resolved, its final value becomes
+ // the .value of the Promise<{value,done}> result for the
+ // current iteration. If the Promise is rejected, however, the
+ // result for this iteration will be rejected with the same
+ // reason. Note that rejections of yielded Promises are not
+ // thrown back into the generator function, as is the case
+ // when an awaited Promise is rejected. This difference in
+ // behavior between yield and await is important, because it
+ // allows the consumer to decide what to do with the yielded
+ // rejection (swallow it and continue, manually .throw it back
+ // into the generator, abandon iteration, whatever). With
+ // await, by contrast, there is no opportunity to examine the
+ // rejection reason outside the generator function, so the
+ // only option is to throw it from the await expression, and
+ // let the generator function handle the exception.
+ result.value = unwrapped;
+ resolve(result);
+ }, reject);
+ }
+ }
+
+ if (typeof global.process === "object" && global.process.domain) {
+ invoke = global.process.domain.bind(invoke);
+ }
+
+ var previousPromise;
+
+ function enqueue(method, arg) {
+ function callInvokeWithMethodAndArg() {
+ return new Promise(function(resolve, reject) {
+ invoke(method, arg, resolve, reject);
+ });
+ }
+
+ return previousPromise =
+ // If enqueue has been called before, then we want to wait until
+ // all previous Promises have been resolved before calling invoke,
+ // so that results are always delivered in the correct order. If
+ // enqueue has not been called before, then it is important to
+ // call invoke immediately, without waiting on a callback to fire,
+ // so that the async generator function has the opportunity to do
+ // any necessary setup in a predictable way. This predictability
+ // is why the Promise constructor synchronously invokes its
+ // executor callback, and why async functions synchronously
+ // execute code before the first await. Since we implement simple
+ // async functions in terms of async generators, it is especially
+ // important to get this right, even though it requires care.
+ previousPromise ? previousPromise.then(
+ callInvokeWithMethodAndArg,
+ // Avoid propagating failures to Promises returned by later
+ // invocations of the iterator.
+ callInvokeWithMethodAndArg
+ ) : callInvokeWithMethodAndArg();
+ }
+
+ // Define the unified helper method that is used to implement .next,
+ // .throw, and .return (see defineIteratorMethods).
+ this._invoke = enqueue;
+ }
+
+ defineIteratorMethods(AsyncIterator.prototype);
+ AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+ return this;
+ };
+ runtime.AsyncIterator = AsyncIterator;
+
+ // Note that simple async functions are implemented on top of
+ // AsyncIterator objects; they just return a Promise for the value of
+ // the final result produced by the iterator.
+ runtime.async = function(innerFn, outerFn, self, tryLocsList) {
+ var iter = new AsyncIterator(
+ wrap(innerFn, outerFn, self, tryLocsList)
+ );
+
+ return runtime.isGeneratorFunction(outerFn)
+ ? iter // If outerFn is a generator, return the full iterator.
+ : iter.next().then(function(result) {
+ return result.done ? result.value : iter.next();
+ });
+ };
+
+ function makeInvokeMethod(innerFn, self, context) {
+ var state = GenStateSuspendedStart;
+
+ return function invoke(method, arg) {
+ if (state === GenStateExecuting) {
+ throw new Error("Generator is already running");
+ }
+
+ if (state === GenStateCompleted) {
+ if (method === "throw") {
+ throw arg;
+ }
+
+ // Be forgiving, per 25.3.3.3.3 of the spec:
+ // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+ return doneResult();
+ }
+
+ context.method = method;
+ context.arg = arg;
+
+ while (true) {
+ var delegate = context.delegate;
+ if (delegate) {
+ var delegateResult = maybeInvokeDelegate(delegate, context);
+ if (delegateResult) {
+ if (delegateResult === ContinueSentinel) continue;
+ return delegateResult;
+ }
+ }
+
+ if (context.method === "next") {
+ // Setting context._sent for legacy support of Babel's
+ // function.sent implementation.
+ context.sent = context._sent = context.arg;
+
+ } else if (context.method === "throw") {
+ if (state === GenStateSuspendedStart) {
+ state = GenStateCompleted;
+ throw context.arg;
+ }
+
+ context.dispatchException(context.arg);
+
+ } else if (context.method === "return") {
+ context.abrupt("return", context.arg);
+ }
+
+ state = GenStateExecuting;
+
+ var record = tryCatch(innerFn, self, context);
+ if (record.type === "normal") {
+ // If an exception is thrown from innerFn, we leave state ===
+ // GenStateExecuting and loop back for another invocation.
+ state = context.done
+ ? GenStateCompleted
+ : GenStateSuspendedYield;
+
+ if (record.arg === ContinueSentinel) {
+ continue;
+ }
+
+ return {
+ value: record.arg,
+ done: context.done
+ };
+
+ } else if (record.type === "throw") {
+ state = GenStateCompleted;
+ // Dispatch the exception by looping back around to the
+ // context.dispatchException(context.arg) call above.
+ context.method = "throw";
+ context.arg = record.arg;
+ }
+ }
+ };
+ }
+
+ // Call delegate.iterator[context.method](context.arg) and handle the
+ // result, either by returning a { value, done } result from the
+ // delegate iterator, or by modifying context.method and context.arg,
+ // setting context.delegate to null, and returning the ContinueSentinel.
+ function maybeInvokeDelegate(delegate, context) {
+ var method = delegate.iterator[context.method];
+ if (method === undefined) {
+ // A .throw or .return when the delegate iterator has no .throw
+ // method always terminates the yield* loop.
+ context.delegate = null;
+
+ if (context.method === "throw") {
+ if (delegate.iterator.return) {
+ // If the delegate iterator has a return method, give it a
+ // chance to clean up.
+ context.method = "return";
+ context.arg = undefined;
+ maybeInvokeDelegate(delegate, context);
+
+ if (context.method === "throw") {
+ // If maybeInvokeDelegate(context) changed context.method from
+ // "return" to "throw", let that override the TypeError below.
+ return ContinueSentinel;
+ }
+ }
+
+ context.method = "throw";
+ context.arg = new TypeError(
+ "The iterator does not provide a 'throw' method");
+ }
+
+ return ContinueSentinel;
+ }
+
+ var record = tryCatch(method, delegate.iterator, context.arg);
+
+ if (record.type === "throw") {
+ context.method = "throw";
+ context.arg = record.arg;
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ var info = record.arg;
+
+ if (! info) {
+ context.method = "throw";
+ context.arg = new TypeError("iterator result is not an object");
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ if (info.done) {
+ // Assign the result of the finished delegate to the temporary
+ // variable specified by delegate.resultName (see delegateYield).
+ context[delegate.resultName] = info.value;
+
+ // Resume execution at the desired location (see delegateYield).
+ context.next = delegate.nextLoc;
+
+ // If context.method was "throw" but the delegate handled the
+ // exception, let the outer generator proceed normally. If
+ // context.method was "next", forget context.arg since it has been
+ // "consumed" by the delegate iterator. If context.method was
+ // "return", allow the original .return call to continue in the
+ // outer generator.
+ if (context.method !== "return") {
+ context.method = "next";
+ context.arg = undefined;
+ }
+
+ } else {
+ // Re-yield the result returned by the delegate method.
+ return info;
+ }
+
+ // The delegate iterator is finished, so forget it and continue with
+ // the outer generator.
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ // Define Generator.prototype.{next,throw,return} in terms of the
+ // unified ._invoke helper method.
+ defineIteratorMethods(Gp);
+
+ Gp[toStringTagSymbol] = "Generator";
+
+ // A Generator should always return itself as the iterator object when the
+ // @@iterator function is called on it. Some browsers' implementations of the
+ // iterator prototype chain incorrectly implement this, causing the Generator
+ // object to not be returned from this call. This ensures that doesn't happen.
+ // See https://github.com/facebook/regenerator/issues/274 for more details.
+ Gp[iteratorSymbol] = function() {
+ return this;
+ };
+
+ Gp.toString = function() {
+ return "[object Generator]";
+ };
+
+ function pushTryEntry(locs) {
+ var entry = { tryLoc: locs[0] };
+
+ if (1 in locs) {
+ entry.catchLoc = locs[1];
+ }
+
+ if (2 in locs) {
+ entry.finallyLoc = locs[2];
+ entry.afterLoc = locs[3];
+ }
+
+ this.tryEntries.push(entry);
+ }
+
+ function resetTryEntry(entry) {
+ var record = entry.completion || {};
+ record.type = "normal";
+ delete record.arg;
+ entry.completion = record;
+ }
+
+ function Context(tryLocsList) {
+ // The root entry object (effectively a try statement without a catch
+ // or a finally block) gives us a place to store values thrown from
+ // locations where there is no enclosing try statement.
+ this.tryEntries = [{ tryLoc: "root" }];
+ tryLocsList.forEach(pushTryEntry, this);
+ this.reset(true);
+ }
+
+ runtime.keys = function(object) {
+ var keys = [];
+ for (var key in object) {
+ keys.push(key);
+ }
+ keys.reverse();
+
+ // Rather than returning an object with a next method, we keep
+ // things simple and return the next function itself.
+ return function next() {
+ while (keys.length) {
+ var key = keys.pop();
+ if (key in object) {
+ next.value = key;
+ next.done = false;
+ return next;
+ }
+ }
+
+ // To avoid creating an additional object, we just hang the .value
+ // and .done properties off the next function object itself. This
+ // also ensures that the minifier will not anonymize the function.
+ next.done = true;
+ return next;
+ };
+ };
+
+ function values(iterable) {
+ if (iterable) {
+ var iteratorMethod = iterable[iteratorSymbol];
+ if (iteratorMethod) {
+ return iteratorMethod.call(iterable);
+ }
+
+ if (typeof iterable.next === "function") {
+ return iterable;
+ }
+
+ if (!isNaN(iterable.length)) {
+ var i = -1, next = function next() {
+ while (++i < iterable.length) {
+ if (hasOwn.call(iterable, i)) {
+ next.value = iterable[i];
+ next.done = false;
+ return next;
+ }
+ }
+
+ next.value = undefined;
+ next.done = true;
+
+ return next;
+ };
+
+ return next.next = next;
+ }
+ }
+
+ // Return an iterator with no values.
+ return { next: doneResult };
+ }
+ runtime.values = values;
+
+ function doneResult() {
+ return { value: undefined, done: true };
+ }
+
+ Context.prototype = {
+ constructor: Context,
+
+ reset: function(skipTempReset) {
+ this.prev = 0;
+ this.next = 0;
+ // Resetting context._sent for legacy support of Babel's
+ // function.sent implementation.
+ this.sent = this._sent = undefined;
+ this.done = false;
+ this.delegate = null;
+
+ this.method = "next";
+ this.arg = undefined;
+
+ this.tryEntries.forEach(resetTryEntry);
+
+ if (!skipTempReset) {
+ for (var name in this) {
+ // Not sure about the optimal order of these conditions:
+ if (name.charAt(0) === "t" &&
+ hasOwn.call(this, name) &&
+ !isNaN(+name.slice(1))) {
+ this[name] = undefined;
+ }
+ }
+ }
+ },
+
+ stop: function() {
+ this.done = true;
+
+ var rootEntry = this.tryEntries[0];
+ var rootRecord = rootEntry.completion;
+ if (rootRecord.type === "throw") {
+ throw rootRecord.arg;
+ }
+
+ return this.rval;
+ },
+
+ dispatchException: function(exception) {
+ if (this.done) {
+ throw exception;
+ }
+
+ var context = this;
+ function handle(loc, caught) {
+ record.type = "throw";
+ record.arg = exception;
+ context.next = loc;
+
+ if (caught) {
+ // If the dispatched exception was caught by a catch block,
+ // then let that catch block handle the exception normally.
+ context.method = "next";
+ context.arg = undefined;
+ }
+
+ return !! caught;
+ }
+
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ var record = entry.completion;
+
+ if (entry.tryLoc === "root") {
+ // Exception thrown outside of any try block that could handle
+ // it, so set the completion value of the entire function to
+ // throw the exception.
+ return handle("end");
+ }
+
+ if (entry.tryLoc <= this.prev) {
+ var hasCatch = hasOwn.call(entry, "catchLoc");
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+ if (hasCatch && hasFinally) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ } else if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+
+ } else if (hasCatch) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ }
+
+ } else if (hasFinally) {
+ if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+
+ } else {
+ throw new Error("try statement without catch or finally");
+ }
+ }
+ }
+ },
+
+ abrupt: function(type, arg) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ if (entry.tryLoc <= this.prev &&
+ hasOwn.call(entry, "finallyLoc") &&
+ this.prev < entry.finallyLoc) {
+ var finallyEntry = entry;
+ break;
+ }
+ }
+
+ if (finallyEntry &&
+ (type === "break" ||
+ type === "continue") &&
+ finallyEntry.tryLoc <= arg &&
+ arg <= finallyEntry.finallyLoc) {
+ // Ignore the finally entry if control is not jumping to a
+ // location outside the try/catch block.
+ finallyEntry = null;
+ }
+
+ var record = finallyEntry ? finallyEntry.completion : {};
+ record.type = type;
+ record.arg = arg;
+
+ if (finallyEntry) {
+ this.method = "next";
+ this.next = finallyEntry.finallyLoc;
+ return ContinueSentinel;
+ }
+
+ return this.complete(record);
+ },
+
+ complete: function(record, afterLoc) {
+ if (record.type === "throw") {
+ throw record.arg;
+ }
+
+ if (record.type === "break" ||
+ record.type === "continue") {
+ this.next = record.arg;
+ } else if (record.type === "return") {
+ this.rval = this.arg = record.arg;
+ this.method = "return";
+ this.next = "end";
+ } else if (record.type === "normal" && afterLoc) {
+ this.next = afterLoc;
+ }
+
+ return ContinueSentinel;
+ },
+
+ finish: function(finallyLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ if (entry.finallyLoc === finallyLoc) {
+ this.complete(entry.completion, entry.afterLoc);
+ resetTryEntry(entry);
+ return ContinueSentinel;
+ }
+ }
+ },
+
+ "catch": function(tryLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ if (entry.tryLoc === tryLoc) {
+ var record = entry.completion;
+ if (record.type === "throw") {
+ var thrown = record.arg;
+ resetTryEntry(entry);
+ }
+ return thrown;
+ }
+ }
+
+ // The context.catch method must only be called with a location
+ // argument that corresponds to a known catch block.
+ throw new Error("illegal catch attempt");
+ },
+
+ delegateYield: function(iterable, resultName, nextLoc) {
+ this.delegate = {
+ iterator: values(iterable),
+ resultName: resultName,
+ nextLoc: nextLoc
+ };
+
+ if (this.method === "next") {
+ // Deliberately forget the last sent value so that we don't
+ // accidentally pass it on to the delegate.
+ this.arg = undefined;
+ }
+
+ return ContinueSentinel;
+ }
+ };
+})(
+ // Among the various tricks for obtaining a reference to the global
+ // object, this seems to be the most reliable technique that does not
+ // use indirect eval (which violates Content Security Policy).
+ typeof global === "object" ? global :
+ typeof window === "object" ? window :
+ typeof self === "object" ? self : this
+);
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "./node_modules/base64-js/index.js":
+/*!*****************************************!*\
+ !*** ./node_modules/base64-js/index.js ***!
+ \*****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i]
+ revLookup[code.charCodeAt(i)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens (b64) {
+ var len = b64.length
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf('=')
+ if (validLen === -1) validLen = len
+
+ var placeHoldersLen = validLen === len
+ ? 0
+ : 4 - (validLen % 4)
+
+ return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+ var tmp
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+ var curByte = 0
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0
+ ? validLen - 4
+ : validLen
+
+ var i
+ for (i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)]
+ arr[curByte++] = (tmp >> 16) & 0xFF
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4)
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2)
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ return arr
+}
+
+function tripletToBase64 (num) {
+ return lookup[num >> 18 & 0x3F] +
+ lookup[num >> 12 & 0x3F] +
+ lookup[num >> 6 & 0x3F] +
+ lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+ var tmp
+ var output = []
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xFF0000) +
+ ((uint8[i + 1] << 8) & 0xFF00) +
+ (uint8[i + 2] & 0xFF)
+ output.push(tripletToBase64(tmp))
+ }
+ return output.join('')
+}
+
+function fromByteArray (uint8) {
+ var tmp
+ var len = uint8.length
+ var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+ var parts = []
+ var maxChunkLength = 16383 // must be multiple of 3
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 2] +
+ lookup[(tmp << 4) & 0x3F] +
+ '=='
+ )
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3F] +
+ lookup[(tmp << 2) & 0x3F] +
+ '='
+ )
+ }
+
+ return parts.join('')
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/buffer/index.js":
+/*!**************************************!*\
+ !*** ./node_modules/buffer/index.js ***!
+ \**************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh