anastasis-core: provide reducer CLI, refactor state machine

11 files changed, 2425 insertions, 445 deletions

diff --git a/package.json b/package.json
index 95ef6f5e1..b6e27b997 100644
--- a/package.json
+++ b/package.json
@@ -8,8 +8,8 @@
     "check": "pnpm run --filter '{packages}' --if-present test"
   },
   "devDependencies": {
-    "@linaria/esbuild": "^3.0.0-beta.7",
-    "@linaria/shaker": "^3.0.0-beta.7",
-    "esbuild": "^0.12.21"
+    "@linaria/esbuild": "^3.0.0-beta.13",
+    "@linaria/shaker": "^3.0.0-beta.13",
+    "esbuild": "^0.12.29"
   }
 }
diff --git a/packages/anastasis-core/bin/anastasis-ts-reducer.js b/packages/anastasis-core/bin/anastasis-ts-reducer.js
new file mode 100755
index 000000000..9e1120516
--- /dev/null
+++ b/packages/anastasis-core/bin/anastasis-ts-reducer.js
@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+async function r() {
+  try {
+    (await import("source-map-support")).install();
+  } catch (e) {
+    console.warn("can't load souremaps");
+    // Do nothing.
+  }
+
+  (await import("../dist/anastasis-cli.js")).reducerCliMain();
+}
+
+r();
diff --git a/packages/anastasis-core/package.json b/packages/anastasis-core/package.json
index 8dbef2d45..7e4fba9e3 100644
--- a/packages/anastasis-core/package.json
+++ b/packages/anastasis-core/package.json
@@ -6,8 +6,8 @@
   "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
-    "prepare": "tsc",
-    "compile": "tsc",
+    "prepare": "tsc && rollup -c",
+    "compile": "tsc && rollup -c",
     "pretty": "prettier --write src",
     "test": "tsc && ava",
     "coverage": "tsc && nyc ava",
@@ -17,15 +17,23 @@
   "license": "AGPL-3-or-later",
   "type": "module",
   "devDependencies": {
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.6",
     "ava": "^3.15.0",
-    "typescript": "^4.4.3"
+    "rimraf": "^3.0.2",
+    "rollup": "^2.59.0",
+    "rollup-plugin-sourcemaps": "^0.6.3",
+    "source-map-support": "^0.5.19",
+    "typescript": "^4.4.4"
   },
   "dependencies": {
     "@gnu-taler/taler-util": "workspace:^0.8.3",
     "fetch-ponyfill": "^7.1.0",
     "fflate": "^0.6.0",
     "hash-wasm": "^4.9.0",
-    "node-fetch": "^3.0.0"
+    "node-fetch": "^3.0.0",
+    "tslib": "^2.1.0"
   },
   "ava": {
     "files": [
diff --git a/packages/anastasis-core/rollup.config.js b/packages/anastasis-core/rollup.config.js
new file mode 100644
index 000000000..59998c93b
--- /dev/null
+++ b/packages/anastasis-core/rollup.config.js
@@ -0,0 +1,30 @@
+// rollup.config.js
+import commonjs from "@rollup/plugin-commonjs";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import json from "@rollup/plugin-json";
+import builtins from "builtin-modules";
+import sourcemaps from "rollup-plugin-sourcemaps";
+
+export default {
+  input: "lib/index.node.js",
+  output: {
+    file: "dist/anastasis-cli.js",
+    format: "es",
+    sourcemap: true,
+  },
+  external: builtins,
+  plugins: [
+    nodeResolve({
+      preferBuiltins: true,
+    }),
+
+    sourcemaps(),
+
+    commonjs({
+      sourceMap: true,
+      transformMixedEsModules: true,
+    }),
+
+    json(),
+  ],
+};
diff --git a/packages/anastasis-core/src/cli.ts b/packages/anastasis-core/src/cli.ts
new file mode 100644
index 000000000..5ab7af6db
--- /dev/null
+++ b/packages/anastasis-core/src/cli.ts
@@ -0,0 +1,64 @@
+import { clk } from "@gnu-taler/taler-util";
+import {
+  getBackupStartState,
+  getRecoveryStartState,
+  reduceAction,
+} from "./index.js";
+import fs from "fs";
+
+export const reducerCli = clk
+  .program("reducer", {
+    help: "Command line interface for the GNU Taler wallet.",
+  })
+  .flag("initBackup", ["-b", "--backup"])
+  .flag("initRecovery", ["-r", "--restore"])
+  .maybeOption("argumentsJson", ["-a", "--arguments"], clk.STRING)
+  .maybeArgument("action", clk.STRING)
+  .maybeArgument("stateFile", clk.STRING);
+
+async function read(stream: NodeJS.ReadStream): Promise<string> {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+reducerCli.action(async (x) => {
+  if (x.reducer.initBackup) {
+    console.log(JSON.stringify(await getBackupStartState()));
+    return;
+  } else if (x.reducer.initRecovery) {
+    console.log(JSON.stringify(await getRecoveryStartState()));
+    return;
+  }
+
+  const action = x.reducer.action;
+  if (!action) {
+    console.log("action required");
+    return;
+  }
+
+  let lastState: any;
+  if (x.reducer.stateFile) {
+    const s = fs.readFileSync(x.reducer.stateFile, { encoding: "utf-8" });
+    lastState = JSON.parse(s);
+  } else {
+    const s = await read(process.stdin);
+    lastState = JSON.parse(s);
+  }
+
+  let args: any;
+  if (x.reducer.argumentsJson) {
+    args = JSON.parse(x.reducer.argumentsJson);
+  } else {
+    args = {};
+  }
+
+  const nextState = await reduceAction(lastState, action, args);
+  console.log(JSON.stringify(nextState));
+});
+
+export function reducerCliMain() {
+  reducerCli.run();
+}
diff --git a/packages/anastasis-core/src/index.node.ts b/packages/anastasis-core/src/index.node.ts
new file mode 100644
index 000000000..d08906a22
--- /dev/null
+++ b/packages/anastasis-core/src/index.node.ts
@@ -0,0 +1,2 @@
+export * from "./index.js";
+export { reducerCliMain } from "./cli.js";
diff --git a/packages/anastasis-core/src/index.ts b/packages/anastasis-core/src/index.ts
index c9e2bcf36..07f8122e3 100644
--- a/packages/anastasis-core/src/index.ts
+++ b/packages/anastasis-core/src/index.ts
@@ -9,6 +9,8 @@ import {
   encodeCrock,
   getRandomBytes,
   hash,
+  j2s,
+  Logger,
   stringToBytes,
   TalerErrorCode,
   TalerSignaturePurpose,
@@ -26,12 +28,22 @@ import {
   ActionArgEnterSecret,
   ActionArgEnterSecretName,
   ActionArgEnterUserAttributes,
+  ActionArgsAddPolicy,
+  ActionArgSelectContinent,
+  ActionArgSelectCountry,
   ActionArgsSelectChallenge,
   ActionArgsSolveChallengeRequest,
+  ActionArgsUpdateExpiration,
   AuthenticationProviderStatus,
   AuthenticationProviderStatusOk,
   AuthMethod,
   BackupStates,
+  codecForActionArgEnterUserAttributes,
+  codecForActionArgsAddPolicy,
+  codecForActionArgSelectChallenge,
+  codecForActionArgSelectContinent,
+  codecForActionArgSelectCountry,
+  codecForActionArgsUpdateExpiration,
   ContinentInfo,
   CountryInfo,
   MethodSpec,
@@ -46,6 +58,7 @@ import {
   ReducerStateError,
   ReducerStateRecovery,
   SuccessDetails,
+  UserAttributeSpec,
 } from "./reducer-types.js";
 import fetchPonyfill from "fetch-ponyfill";
 import {
@@ -61,8 +74,6 @@ import {
   PolicySalt,
   TruthSalt,
   secureAnswerHash,
-  TruthKey,
-  TruthUuid,
   UserIdentifier,
   userIdentifierDerive,
   typedArrayConcat,
@@ -74,10 +85,12 @@ import {
 import { unzlibSync, zlibSync } from "fflate";
 import { EscrowMethod, RecoveryDocument } from "./recovery-document-types.js";
 
-const { fetch, Request, Response, Headers } = fetchPonyfill({});
+const { fetch } = fetchPonyfill({});
 
 export * from "./reducer-types.js";
-export * as validators from './validators.js';
+export * as validators from "./validators.js";
+
+const logger = new Logger("anastasis-core:index.ts");
 
 function getContinents(): ContinentInfo[] {
   const continentSet = new Set<string>();
@@ -95,10 +108,40 @@ function getContinents(): ContinentInfo[] {
   return continents;
 }
 
+interface ErrorDetails {
+  code: TalerErrorCode;
+  message?: string;
+  hint?: string;
+}
+
+export class ReducerError extends Error {
+  constructor(public errorJson: ErrorDetails) {
+    super(
+      errorJson.message ??
+        errorJson.hint ??
+        `${TalerErrorCode[errorJson.code]}`,
+    );
+
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, ReducerError.prototype);
+  }
+}
+
+/**
+ * Get countries for a continent, abort with ReducerError
+ * exception when continent doesn't exist.
+ */
 function getCountries(continent: string): CountryInfo[] {
-  return anastasisData.countriesList.countries.filter(
+  const countries = anastasisData.countriesList.countries.filter(
     (x) => x.continent === continent,
   );
+  if (countries.length <= 0) {
+    throw new ReducerError({
+      code: TalerErrorCode.ANASTASIS_REDUCER_INPUT_INVALID,
+      hint: "continent not found",
+    });
+  }
+  return countries;
 }
 
 export async function getBackupStartState(): Promise<ReducerStateBackup> {
@@ -115,19 +158,27 @@ export async function getRecoveryStartState(): Promise<ReducerStateRecovery> {
   };
 }
 
-async function backupSelectCountry(
-  state: ReducerStateBackup,
-  countryCode: string,
-  currencies: string[],
-): Promise<ReducerStateError | ReducerStateBackupUserAttributesCollecting> {
+async function selectCountry(
+  selectedContinent: string,
+  args: ActionArgSelectCountry,
+): Promise<Partial<ReducerStateBackup> & Partial<ReducerStateRecovery>> {
+  const countryCode = args.country_code;
+  const currencies = args.currencies;
   const country = anastasisData.countriesList.countries.find(
     (x) => x.code === countryCode,
   );
   if (!country) {
-    return {
+    throw new ReducerError({
       code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
       hint: "invalid country selected",
-    };
+    });
+  }
+
+  if (country.continent !== selectedContinent) {
+    throw new ReducerError({
+      code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
+      hint: "selected country is not in selected continent",
+    });
   }
 
   const providers: { [x: string]: {} } = {};
@@ -141,8 +192,6 @@ async function backupSelectCountry(
     .required_attributes;
 
   return {
-    ...state,
-    backup_state: BackupStates.UserAttributesCollecting,
     selected_country: countryCode,
     currencies,
     required_attributes: ra,
@@ -150,38 +199,25 @@ async function backupSelectCountry(
   };
 }
 
+async function backupSelectCountry(
+  state: ReducerStateBackup,
+  args: ActionArgSelectCountry,
+): Promise<ReducerStateError | ReducerStateBackup> {
+  return {
+    ...state,
+    ...(await selectCountry(state.selected_continent!, args)),
+    backup_state: BackupStates.UserAttributesCollecting,
+  };
+}
+
 async function recoverySelectCountry(
   state: ReducerStateRecovery,
-  countryCode: string,
-  currencies: string[],
+  args: ActionArgSelectCountry,
 ): Promise<ReducerStateError | ReducerStateRecovery> {
-  const country = anastasisData.countriesList.countries.find(
-    (x) => x.code === countryCode,
-  );
-  if (!country) {
-    return {
-      code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-      hint: "invalid country selected",
-    };
-  }
-
-  const providers: { [x: string]: {} } = {};
-  for (const prov of anastasisData.providersList.anastasis_provider) {
-    if (currencies.includes(prov.currency)) {
-      providers[prov.url] = {};
-    }
-  }
-
-  const ra = (anastasisData.countryDetails as any)[countryCode]
-    .required_attributes;
-
   return {
     ...state,
     recovery_state: RecoveryStates.UserAttributesCollecting,
-    selected_country: countryCode,
-    currencies,
-    required_attributes: ra,
-    authentication_providers: providers,
+    ...(await selectCountry(state.selected_continent!, args)),
   };
 }
 
@@ -231,8 +267,9 @@ async function getProviderInfo(
 
 async function backupEnterUserAttributes(
   state: ReducerStateBackup,
-  attributes: Record<string, string>,
+  args: ActionArgEnterUserAttributes,
 ): Promise<ReducerStateBackup> {
+  const attributes = args.identity_attributes;
   const providerUrls = Object.keys(state.authentication_providers ?? {});
   const newProviders = state.authentication_providers ?? {};
   for (const url of providerUrls) {
@@ -336,7 +373,7 @@ function suggestPolicies(
   }
   const policies: Policy[] = [];
   const selections = enumerateSelections(numSel, numMethods);
-  console.log("selections", selections);
+  logger.info(`selections: ${j2s(selections)}`);
   for (const sel of selections) {
     const p = assignProviders(methods, providers, sel);
     if (p) {
@@ -409,7 +446,7 @@ async function getTruthValue(
  * Compress the recovery document and add a size header.
  */
 async function compressRecoveryDoc(rd: any): Promise<Uint8Array> {
-  console.log("recovery document", rd);
+  logger.info(`recovery document: ${j2s(rd)}`);
   const docBytes = stringToBytes(JSON.stringify(rd));
   const sizeHeaderBuf = new ArrayBuffer(4);
   const dvbuf = new DataView(sizeHeaderBuf);
@@ -509,10 +546,6 @@ async function uploadSecret(
         ? bytesToString(decodeCrock(authMethod.challenge))
         : undefined,
     );
-    console.log(
-      "encrypted key share len",
-      decodeCrock(encryptedKeyShare).length,
-    );
     const tur: TruthUploadRequest = {
       encrypted_truth: encryptedTruth,
       key_share_data: encryptedKeyShare,
@@ -550,8 +583,6 @@ async function uploadSecret(
   // the state, since it's possible that we'll run into
   // a provider that requests a payment.
 
-  console.log("policy UUIDs", policyUuids);
-
   const rd: RecoveryDocument = {
     secret_name: secretName,
     encrypted_core_secret: csr.encCoreSecret,
@@ -662,7 +693,6 @@ async function downloadPolicy(
     const rd: RecoveryDocument = await uncompressRecoveryDoc(
       decodeCrock(bodyDecrypted),
     );
-    console.log("rd", rd);
     let policyVersion = 0;
     try {
       policyVersion = Number(resp.headers.get("Anastasis-Version") ?? "0");
@@ -683,7 +713,6 @@ async function downloadPolicy(
   }
   const recoveryInfo: RecoveryInformation = {
     challenges: recoveryDoc.escrow_methods.map((x) => {
-      console.log("providers", newProviderStatus);
       const prov = newProviderStatus[x.url] as AuthenticationProviderStatusOk;
       return {
         cost: prov.methods.find((m) => m.type === x.escrow_type)?.usage_fee!,
@@ -777,8 +806,6 @@ async function solveChallenge(
     },
   });
 
-  console.log(resp);
-
   if (resp.status !== 200) {
     return {
       code: TalerErrorCode.ANASTASIS_TRUTH_CHALLENGE_FAILED,
@@ -825,12 +852,12 @@ async function solveChallenge(
 
 async function recoveryEnterUserAttributes(
   state: ReducerStateRecovery,
-  attributes: Record<string, string>,
+  args: ActionArgEnterUserAttributes,
 ): Promise<ReducerStateRecovery | ReducerStateError> {
   // FIXME: validate attributes
   const st: ReducerStateRecovery = {
     ...state,
-    identity_attributes: attributes,
+    identity_attributes: args.identity_attributes,
   };
   return downloadPolicy(st);
 }
@@ -853,8 +880,6 @@ async function selectChallenge(
     },
   });
 
-  console.log(resp);
-
   return {
     ...state,
     recovery_state: RecoveryStates.ChallengeSolving,
@@ -862,352 +887,386 @@ async function selectChallenge(
   };
 }
 
-export async function reduceAction(
-  state: ReducerState,
-  action: string,
-  args: any,
-): Promise<ReducerState> {
-  console.log(`ts reducer: handling action ${action}`);
-  if (state.backup_state === BackupStates.ContinentSelecting) {
-    if (action === "select_continent") {
-      const continent: string = args.continent;
-      if (typeof continent !== "string") {
-        return {
-          code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-          hint: "continent required",
-        };
-      }
-      return {
-        ...state,
-        backup_state: BackupStates.CountrySelecting,
-        countries: getCountries(continent),
-        selected_continent: continent,
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
-  if (state.backup_state === BackupStates.CountrySelecting) {
-    if (action === "back") {
-      return {
-        ...state,
-        backup_state: BackupStates.ContinentSelecting,
-        countries: undefined,
-      };
-    } else if (action === "select_country") {
-      const countryCode = args.country_code;
-      if (typeof countryCode !== "string") {
-        return {
-          code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-          hint: "country_code required",
-        };
-      }
-      const currencies = args.currencies;
-      return backupSelectCountry(state, countryCode, currencies);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
-  if (state.backup_state === BackupStates.UserAttributesCollecting) {
-    if (action === "back") {
-      return {
-        ...state,
-        backup_state: BackupStates.CountrySelecting,
-      };
-    } else if (action === "enter_user_attributes") {
-      const ta = args as ActionArgEnterUserAttributes;
-      return backupEnterUserAttributes(state, ta.identity_attributes);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
-  if (state.backup_state === BackupStates.AuthenticationsEditing) {
-    if (action === "back") {
-      return {
-        ...state,
-        backup_state: BackupStates.UserAttributesCollecting,
-      };
-    } else if (action === "add_authentication") {
-      const ta = args as ActionArgAddAuthentication;
-      return {
-        ...state,
-        authentication_methods: [
-          ...(state.authentication_methods ?? []),
-          ta.authentication_method,
-        ],
-      };
-    } else if (action === "delete_authentication") {
-      const ta = args as ActionArgDeleteAuthentication;
-      const m = state.authentication_methods ?? [];
-      m.splice(ta.authentication_method, 1);
-      return {
-        ...state,
-        authentication_methods: m,
-      };
-    } else if (action === "next") {
-      const methods = state.authentication_methods ?? [];
-      const providers: ProviderInfo[] = [];
-      for (const provUrl of Object.keys(state.authentication_providers ?? {})) {
-        const prov = state.authentication_providers![provUrl];
-        if ("error_code" in prov) {
-          continue;
-        }
-        if (!("http_status" in prov && prov.http_status === 200)) {
-          continue;
-        }
-        const methodCost: Record<string, AmountString> = {};
-        for (const meth of prov.methods) {
-          methodCost[meth.type] = meth.usage_fee;
-        }
-        providers.push({
-          methodCost,
-          url: provUrl,
-        });
-      }
-      const pol = suggestPolicies(methods, providers);
-      console.log("policies", pol);
-      return {
-        ...state,
-        backup_state: BackupStates.PoliciesReviewing,
-        ...pol,
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
+async function backupSelectContinent(
+  state: ReducerStateBackup,
+  args: ActionArgSelectContinent,
+): Promise<ReducerStateBackup | ReducerStateError> {
+  const countries = getCountries(args.continent);
+  if (countries.length <= 0) {
+    return {
+      code: TalerErrorCode.ANASTASIS_REDUCER_INPUT_INVALID,
+      hint: "continent not found",
+    };
   }
-  if (state.backup_state === BackupStates.PoliciesReviewing) {
-    if (action === "back") {
-      return {
-        ...state,
-        backup_state: BackupStates.AuthenticationsEditing,
-      };
-    } else if (action === "delete_policy") {
-      const ta = args as ActionArgDeletePolicy;
-      const policies = [...(state.policies ?? [])];
-      policies.splice(ta.policy_index, 1);
-      return {
-        ...state,
-        policies,
-      };
-    } else if (action === "next") {
-      return {
-        ...state,
-        backup_state: BackupStates.SecretEditing,
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
+  return {
+    ...state,
+    backup_state: BackupStates.CountrySelecting,
+    countries,
+    selected_continent: args.continent,
+  };
+}
+
+async function recoverySelectContinent(
+  state: ReducerStateRecovery,
+  args: ActionArgSelectContinent,
+): Promise<ReducerStateRecovery | ReducerStateError> {
+  const countries = getCountries(args.continent);
+  return {
+    ...state,
+    recovery_state: RecoveryStates.CountrySelecting,
+    countries,
+    selected_continent: args.continent,
+  };
+}
+
+interface TransitionImpl<S, T> {
+  argCodec: Codec<T>;
+  handler: (s: S, args: T) => Promise<S | ReducerStateError>;
+}
+
+interface Transition<S, T> {
+  [x: string]: TransitionImpl<S, T>;
+}
+
+function transition<S, T>(
+  action: string,
+  argCodec: Codec<T>,
+  handler: (s: S, args: T) => Promise<S | ReducerStateError>,
+): Transition<S, T> {
+  return {
+    [action]: {
+      argCodec,
+      handler,
+    },
+  };
+}
+
+function transitionBackupJump(
+  action: string,
+  st: BackupStates,
+): Transition<ReducerStateBackup, void> {
+  return {
+    [action]: {
+      argCodec: codecForAny(),
+      handler: async (s, a) => ({ ...s, backup_state: st }),
+    },
+  };
+}
+
+function transitionRecoveryJump(
+  action: string,
+  st: RecoveryStates,
+): Transition<ReducerStateRecovery, void> {
+  return {
+    [action]: {
+      argCodec: codecForAny(),
+      handler: async (s, a) => ({ ...s, recovery_state: st }),
+    },
+  };
+}
+
+async function addAuthentication(
+  state: ReducerStateBackup,
+  args: ActionArgAddAuthentication,
+): Promise<ReducerStateBackup> {
+  return {
+    ...state,
+    authentication_methods: [
+      ...(state.authentication_methods ?? []),
+      args.authentication_method,
+    ],
+  };
+}
+
+async function deleteAuthentication(
+  state: ReducerStateBackup,
+  args: ActionArgDeleteAuthentication,
+): Promise<ReducerStateBackup> {
+  const m = state.authentication_methods ?? [];
+  m.splice(args.authentication_method, 1);
+  return {
+    ...state,
+    authentication_methods: m,
+  };
+}
+
+async function deletePolicy(
+  state: ReducerStateBackup,
+  args: ActionArgDeletePolicy,
+): Promise<ReducerStateBackup> {
+  const policies = [...(state.policies ?? [])];
+  policies.splice(args.policy_index, 1);
+  return {
+    ...state,
+    policies,
+  };
+}
+
+async function addPolicy(
+  state: ReducerStateBackup,
+  args: ActionArgsAddPolicy,
+): Promise<ReducerStateBackup> {
+  return {
+    ...state,
+    policies: [
+      ...(state.policies ?? []),
+      {
+        methods: args.policy,
+      },
+    ],
+  };
+}
+
+async function nextFromAuthenticationsEditing(
+  state: ReducerStateBackup,
+  args: {},
+): Promise<ReducerStateBackup | ReducerStateError> {
+  const methods = state.authentication_methods ?? [];
+  const providers: ProviderInfo[] = [];
+  for (const provUrl of Object.keys(state.authentication_providers ?? {})) {
+    const prov = state.authentication_providers![provUrl];
+    if ("error_code" in prov) {
+      continue;
     }
-  }
-  if (state.backup_state === BackupStates.SecretEditing) {
-    if (action === "back") {
-      return {
-        ...state,
-        backup_state: BackupStates.PoliciesReviewing,
-      };
-    } else if (action === "enter_secret_name") {
-      const ta = args as ActionArgEnterSecretName;
-      return {
-        ...state,
-        secret_name: ta.name,
-      };
-    } else if (action === "enter_secret") {
-      const ta = args as ActionArgEnterSecret;
-      return {
-        ...state,
-        expiration: ta.expiration,
-        core_secret: {
-          mime: ta.secret.mime ?? "text/plain",
-          value: ta.secret.value,
-        },
-      };
-    } else if (action === "next") {
-      return uploadSecret(state);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
+    if (!("http_status" in prov && prov.http_status === 200)) {
+      continue;
     }
-  }
-  if (state.backup_state === BackupStates.BackupFinished) {
-    if (action === "back") {
-      return {
-        ...state,
-        backup_state: BackupStates.SecretEditing,
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
+    const methodCost: Record<string, AmountString> = {};
+    for (const meth of prov.methods) {
+      methodCost[meth.type] = meth.usage_fee;
     }
+    providers.push({
+      methodCost,
+      url: provUrl,
+    });
   }
+  const pol = suggestPolicies(methods, providers);
+  return {
+    ...state,
+    backup_state: BackupStates.PoliciesReviewing,
+    ...pol,
+  };
+}
 
-  if (state.recovery_state === RecoveryStates.ContinentSelecting) {
-    if (action === "select_continent") {
-      const continent: string = args.continent;
-      if (typeof continent !== "string") {
-        return {
-          code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-          hint: "continent required",
-        };
-      }
-      return {
-        ...state,
-        recovery_state: RecoveryStates.CountrySelecting,
-        countries: getCountries(continent),
-        selected_continent: continent,
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
+async function updateUploadFees(
+  state: ReducerStateBackup,
+): Promise<ReducerStateBackup | ReducerStateError> {
+  for (const prov of state.policy_providers ?? []) {
+    const info = state.authentication_providers![prov.provider_url];
+    if (!("currency" in info)) {
+      continue;
     }
   }
+  return { ...state, upload_fees: [] };
+}
 
-  if (state.recovery_state === RecoveryStates.CountrySelecting) {
-    if (action === "back") {
-      return {
-        ...state,
-        recovery_state: RecoveryStates.ContinentSelecting,
-        countries: undefined,
-      };
-    } else if (action === "select_country") {
-      const countryCode = args.country_code;
-      if (typeof countryCode !== "string") {
-        return {
-          code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-          hint: "country_code required",
-        };
-      }
-      const currencies = args.currencies;
-      return recoverySelectCountry(state, countryCode, currencies);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
+async function enterSecret(
+  state: ReducerStateBackup,
+  args: ActionArgEnterSecret,
+): Promise<ReducerStateBackup | ReducerStateError> {
+  return {
+    ...state,
+    expiration: args.expiration,
+    core_secret: {
+      mime: args.secret.mime ?? "text/plain",
+      value: args.secret.value,
+    },
+  };
+}
 
-  if (state.recovery_state === RecoveryStates.UserAttributesCollecting) {
-    if (action === "back") {
-      return {
-        ...state,
-        recovery_state: RecoveryStates.CountrySelecting,
-      };
-    } else if (action === "enter_user_attributes") {
-      const ta = args as ActionArgEnterUserAttributes;
-      return recoveryEnterUserAttributes(state, ta.identity_attributes);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
+async function nextFromChallengeSelecting(
+  state: ReducerStateRecovery,
+  args: void,
+): Promise<ReducerStateRecovery | ReducerStateError> {
+  const s2 = await tryRecoverSecret(state);
+  if (s2.recovery_state === RecoveryStates.RecoveryFinished) {
+    return s2;
   }
+  return {
+    code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
+    hint: "Not enough challenges solved",
+  };
+}
 
-  if (state.recovery_state === RecoveryStates.SecretSelecting) {
-    if (action === "back") {
-      return {
-        ...state,
-        recovery_state: RecoveryStates.UserAttributesCollecting,
-      };
-    } else if (action === "next") {
-      return {
-        ...state,
-        recovery_state: RecoveryStates.ChallengeSelecting,
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
+async function enterSecretName(
+  state: ReducerStateBackup,
+  args: ActionArgEnterSecretName,
+): Promise<ReducerStateBackup | ReducerStateError> {
+  return {
+    ...state,
+    secret_name: args.name,
+  };
+}
 
-  if (state.recovery_state === RecoveryStates.ChallengeSelecting) {
-    if (action === "select_challenge") {
-      const ta: ActionArgsSelectChallenge = args;
-      return selectChallenge(state, ta);
-    } else if (action === "back") {
-      return {
-        ...state,
-        recovery_state: RecoveryStates.SecretSelecting,
-      };
-    } else if (action === "next") {
-      const s2 = await tryRecoverSecret(state);
-      if (s2.recovery_state === RecoveryStates.RecoveryFinished) {
-        return s2;
-      }
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: "Not enough challenges solved",
-      };
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
+async function updateSecretExpiration(
+  state: ReducerStateBackup,
+  args: ActionArgsUpdateExpiration,
+): Promise<ReducerStateBackup | ReducerStateError> {
+  // FIXME: implement!
+  return {
+    ...state,
+    expiration: args.expiration,
+  };
+}
 
-  if (state.recovery_state === RecoveryStates.ChallengeSolving) {
-    if (action === "back") {
-      const ta: ActionArgsSelectChallenge = args;
-      return {
-        ...state,
-        selected_challenge_uuid: undefined,
-        recovery_state: RecoveryStates.ChallengeSelecting,
-      };
-    } else if (action === "solve_challenge") {
-      const ta: ActionArgsSolveChallengeRequest = args;
-      return solveChallenge(state, ta);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
-    }
-  }
+const backupTransitions: Record<
+  BackupStates,
+  Transition<ReducerStateBackup, any>
+> = {
+  [BackupStates.ContinentSelecting]: {
+    ...transition(
+      "select_continent",
+      codecForActionArgSelectContinent(),
+      backupSelectContinent,
+    ),
+  },
+  [BackupStates.CountrySelecting]: {
+    ...transitionBackupJump("back", BackupStates.ContinentSelecting),
+    ...transition(
+      "select_country",
+      codecForActionArgSelectCountry(),
+      backupSelectCountry,
+    ),
+    ...transition(
+      "select_continent",
+      codecForActionArgSelectContinent(),
+      backupSelectContinent,
+    ),
+  },
+  [BackupStates.UserAttributesCollecting]: {
+    ...transitionBackupJump("back", BackupStates.CountrySelecting),
+    ...transition(
+      "enter_user_attributes",
+      codecForActionArgEnterUserAttributes(),
+      backupEnterUserAttributes,
+    ),
+  },
+  [BackupStates.AuthenticationsEditing]: {
+    ...transitionBackupJump("back", BackupStates.UserAttributesCollecting),
+    ...transition("add_authentication", codecForAny(), addAuthentication),
+    ...transition("delete_authentication", codecForAny(), deleteAuthentication),
+    ...transition("next", codecForAny(), nextFromAuthenticationsEditing),
+  },
+  [BackupStates.PoliciesReviewing]: {
+    ...transitionBackupJump("back", BackupStates.AuthenticationsEditing),
+    ...transitionBackupJump("next", BackupStates.SecretEditing),
+    ...transition("add_policy", codecForActionArgsAddPolicy(), addPolicy),
+    ...transition("delete_policy", codecForAny(), deletePolicy),
+  },
+  [BackupStates.SecretEditing]: {
+    ...transitionBackupJump("back", BackupStates.PoliciesPaying),
+    ...transition("next", codecForAny(), uploadSecret),
+    ...transition("enter_secret", codecForAny(), enterSecret),
+    ...transition(
+      "update_expiration",
+      codecForActionArgsUpdateExpiration(),
+      updateSecretExpiration,
+    ),
+    ...transition("enter_secret_name", codecForAny(), enterSecretName),
+  },
+  [BackupStates.PoliciesPaying]: {},
+  [BackupStates.TruthsPaying]: {},
+  [BackupStates.PoliciesPaying]: {},
+  [BackupStates.BackupFinished]: {
+    ...transitionBackupJump("back", BackupStates.SecretEditing),
+  },
+};
+
+const recoveryTransitions: Record<
+  RecoveryStates,
+  Transition<ReducerStateRecovery, any>
+> = {
+  [RecoveryStates.ContinentSelecting]: {
+    ...transition(
+      "select_continent",
+      codecForActionArgSelectContinent(),
+      recoverySelectContinent,
+    ),
+  },
+  [RecoveryStates.CountrySelecting]: {
+    ...transitionRecoveryJump("back", RecoveryStates.ContinentSelecting),
+    ...transition(
+      "select_country",
+      codecForActionArgSelectCountry(),
+      recoverySelectCountry,
+    ),
+    ...transition(
+      "select_continent",
+      codecForActionArgSelectContinent(),
+      recoverySelectContinent,
+    ),
+  },
+  [RecoveryStates.UserAttributesCollecting]: {
+    ...transitionRecoveryJump("back", RecoveryStates.CountrySelecting),
+    ...transition(
+      "enter_user_attributes",
+      codecForActionArgEnterUserAttributes(),
+      recoveryEnterUserAttributes,
+    ),
+  },
+  [RecoveryStates.SecretSelecting]: {
+    ...transitionRecoveryJump("back", RecoveryStates.UserAttributesCollecting),
+    ...transitionRecoveryJump("next", RecoveryStates.ChallengeSelecting),
+  },
+  [RecoveryStates.ChallengeSelecting]: {
+    ...transitionRecoveryJump("back", RecoveryStates.SecretSelecting),
+    ...transition(
+      "select_challenge",
+      codecForActionArgSelectChallenge(),
+      selectChallenge,
+    ),
+    ...transition("next", codecForAny(), nextFromChallengeSelecting),
+  },
+  [RecoveryStates.ChallengeSolving]: {
+    ...transitionRecoveryJump("back", RecoveryStates.ChallengeSelecting),
+    ...transition("solve_challenge", codecForAny(), solveChallenge),
+  },
+  [RecoveryStates.ChallengePaying]: {},
+  [RecoveryStates.RecoveryFinished]: {},
+};
 
-  if (state.recovery_state === RecoveryStates.RecoveryFinished) {
-    if (action === "back") {
-      const ta: ActionArgsSelectChallenge = args;
-      return {
-        ...state,
-        selected_challenge_uuid: undefined,
-        recovery_state: RecoveryStates.ChallengeSelecting,
-      };
-    } else if (action === "solve_challenge") {
-      const ta: ActionArgsSolveChallengeRequest = args;
-      return solveChallenge(state, ta);
-    } else {
-      return {
-        code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-        hint: `Unsupported action '${action}'`,
-      };
+export async function reduceAction(
+  state: ReducerState,
+  action: string,
+  args: any,
+): Promise<ReducerState> {
+  let h: TransitionImpl<any, any>;
+  let stateName: string;
+  if ("backup_state" in state && state.backup_state) {
+    stateName = state.backup_state;
+    h = backupTransitions[state.backup_state][action];
+  } else if ("recovery_state" in state && state.recovery_state) {
+    stateName = state.recovery_state;
+    h = recoveryTransitions[state.recovery_state][action];
+  } else {
+    return {
+      code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
+      hint: `Invalid state (needs backup_state or recovery_state)`,
+    };
+  }
+  if (!h) {
+    return {
+      code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
+      hint: `Unsupported action '${action}' in state '${stateName}'`,
+    };
+  }
+  let parsedArgs: any;
+  try {
+    parsedArgs = h.argCodec.decode(args);
+  } catch (e: any) {
+    return {
+      code: TalerErrorCode.ANASTASIS_REDUCER_INPUT_INVALID,
+      hint: "argument validation failed",
+      message: e.toString(),
+    };
+  }
+  try {
+    return await h.handler(state, parsedArgs);
+  } catch (e) {
+    logger.error("action handler failed");
+    if (e instanceof ReducerError) {
+      return e.errorJson;
     }
+    throw e;
   }
-
-  return {
-    code: TalerErrorCode.ANASTASIS_REDUCER_ACTION_INVALID,
-    hint: "Reducer action invalid",
-  };
 }
diff --git a/packages/anastasis-core/src/reducer-types.ts b/packages/anastasis-core/src/reducer-types.ts
index 57f67f0d0..03883ce17 100644
--- a/packages/anastasis-core/src/reducer-types.ts
+++ b/packages/anastasis-core/src/reducer-types.ts
@@ -1,4 +1,14 @@
-import { Duration, Timestamp } from "@gnu-taler/taler-util";
+import {
+  AmountString,
+  buildCodecForObject,
+  codecForAny,
+  codecForList,
+  codecForNumber,
+  codecForString,
+  codecForTimestamp,
+  Duration,
+  Timestamp,
+} from "@gnu-taler/taler-util";
 import { KeyShare } from "./crypto.js";
 import { RecoveryDocument } from "./recovery-document-types.js";
 
@@ -23,7 +33,7 @@ export interface Policy {
     authentication_method: number;
     provider: string;
   }[];
-} 
+}
 
 export interface PolicyProvider {
   provider_url: string;
@@ -70,7 +80,9 @@ export interface ReducerStateBackup {
 
   core_secret?: CoreSecret;
 
-  expiration?: Duration;
+  expiration?: Timestamp;
+
+  upload_fees?: AmountString[];
 }
 
 export interface AuthMethod {
@@ -94,8 +106,8 @@ export interface UserAttributeSpec {
   uuid: string;
   widget: string;
   optional?: boolean;
-  'validation-regex': string | undefined;
-  'validation-logic': string | undefined;
+  "validation-regex": string | undefined;
+  "validation-logic": string | undefined;
 }
 
 export interface RecoveryInternalData {
@@ -244,6 +256,11 @@ export interface ActionArgEnterUserAttributes {
   identity_attributes: Record<string, string>;
 }
 
+export const codecForActionArgEnterUserAttributes = () =>
+  buildCodecForObject<ActionArgEnterUserAttributes>()
+    .property("identity_attributes", codecForAny())
+    .build("ActionArgEnterUserAttributes");
+
 export interface ActionArgAddAuthentication {
   authentication_method: {
     type: string;
@@ -270,15 +287,69 @@ export interface ActionArgEnterSecret {
     value: string;
     mime?: string;
   };
-  expiration: Duration;
+  expiration: Timestamp;
+}
+
+export interface ActionArgSelectContinent {
+  continent: string;
 }
 
+export const codecForActionArgSelectContinent = () =>
+  buildCodecForObject<ActionArgSelectContinent>()
+    .property("continent", codecForString())
+    .build("ActionArgSelectContinent");
+
+export interface ActionArgSelectCountry {
+  country_code: string;
+  currencies: string[];
+}
+
+export const codecForActionArgSelectCountry = () =>
+  buildCodecForObject<ActionArgSelectCountry>()
+    .property("country_code", codecForString())
+    .property("currencies", codecForList(codecForString()))
+    .build("ActionArgSelectCountry");
+
 export interface ActionArgsSelectChallenge {
   uuid: string;
 }
 
+export const codecForActionArgSelectChallenge = () =>
+  buildCodecForObject<ActionArgsSelectChallenge>()
+    .property("uuid", codecForString())
+    .build("ActionArgSelectChallenge");
+
 export type ActionArgsSolveChallengeRequest = SolveChallengeAnswerRequest;
 
 export interface SolveChallengeAnswerRequest {
   answer: string;
 }
+
+export interface PolicyMember {
+  authentication_method: number;
+  provider: string;
+}
+
+export interface ActionArgsAddPolicy {
+  policy: PolicyMember[];
+}
+
+export const codecForPolicyMember = () =>
+  buildCodecForObject<PolicyMember>()
+    .property("authentication_method", codecForNumber())
+    .property("provider", codecForString())
+    .build("PolicyMember");
+
+export const codecForActionArgsAddPolicy = () =>
+  buildCodecForObject<ActionArgsAddPolicy>()
+    .property("policy", codecForList(codecForPolicyMember()))
+    .build("ActionArgsAddPolicy");
+
+export interface ActionArgsUpdateExpiration {
+  expiration: Timestamp;
+}
+
+export const codecForActionArgsUpdateExpiration = () =>
+  buildCodecForObject<ActionArgsUpdateExpiration>()
+    .property("expiration", codecForTimestamp)
+    .build("ActionArgsUpdateExpiration");
diff --git a/packages/taler-util/src/clk.ts b/packages/taler-util/src/clk.ts
new file mode 100644
index 000000000..d172eed48
--- /dev/null
+++ b/packages/taler-util/src/clk.ts
@@ -0,0 +1,620 @@
+/*
+ This file is part of GNU Taler
+ (C) 2019 GNUnet e.V.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+/**
+ * Imports.
+ */
+import process from "process";
+import path from "path";
+import readline from "readline";
+
+export namespace clk {
+  class Converter<T> {}
+
+  export const INT = new Converter<number>();
+  export const STRING: Converter<string> = new Converter<string>();
+
+  export interface OptionArgs<T> {
+    help?: string;
+    default?: T;
+    onPresentHandler?: (v: T) => void;
+  }
+
+  export interface ArgumentArgs<T> {
+    metavar?: string;
+    help?: string;
+    default?: T;
+  }
+
+  export interface SubcommandArgs {
+    help?: string;
+  }
+
+  export interface FlagArgs {
+    help?: string;
+  }
+
+  export interface ProgramArgs {
+    help?: string;
+  }
+
+  interface ArgumentDef {
+    name: string;
+    conv: Converter<any>;
+    args: ArgumentArgs<any>;
+    required: boolean;
+  }
+
+  interface SubcommandDef {
+    commandGroup: CommandGroup<any, any>;
+    name: string;
+    args: SubcommandArgs;
+  }
+
+  type ActionFn<TG> = (x: TG) => void;
+
+  type SubRecord<S extends keyof any, N extends keyof any, V> = {
+    [Y in S]: { [X in N]: V };
+  };
+
+  interface OptionDef {
+    name: string;
+    flagspec: string[];
+    /**
+     * Converter, only present for options, not for flags.
+     */
+    conv?: Converter<any>;
+    args: OptionArgs<any>;
+    isFlag: boolean;
+    required: boolean;
+  }
+
+  function splitOpt(opt: string): { key: string; value?: string } {
+    const idx = opt.indexOf("=");
+    if (idx == -1) {
+      return { key: opt };
+    }
+    return { key: opt.substring(0, idx), value: opt.substring(idx + 1) };
+  }
+
+  function formatListing(key: string, value?: string): string {
+    const res = "  " + key;
+    if (!value) {
+      return res;
+    }
+    if (res.length >= 25) {
+      return res + "\n" + "    " + value;
+    } else {
+      return res.padEnd(24) + " " + value;
+    }
+  }
+
+  export class CommandGroup<GN extends keyof any, TG> {
+    private shortOptions: { [name: string]: OptionDef } = {};
+    private longOptions: { [name: string]: OptionDef } = {};
+    private subcommandMap: { [name: string]: SubcommandDef } = {};
+    private subcommands: SubcommandDef[] = [];
+    private options: OptionDef[] = [];
+    private arguments: ArgumentDef[] = [];
+
+    private myAction?: ActionFn<TG>;
+
+    constructor(
+      private argKey: string,
+      private name: string | null,
+      private scArgs: SubcommandArgs,
+    ) {}
+
+    action(f: ActionFn<TG>): void {
+      if (this.myAction) {
+        throw Error("only one action supported per command");
+      }
+      this.myAction = f;
+    }
+
+    requiredOption<N extends keyof any, V>(
+      name: N,
+      flagspec: string[],
+      conv: Converter<V>,
+      args: OptionArgs<V> = {},
+    ): CommandGroup<GN, TG & SubRecord<GN, N, V>> {
+      const def: OptionDef = {
+        args: args,
+        conv: conv,
+        flagspec: flagspec,
+        isFlag: false,
+        required: true,
+        name: name as string,
+      };
+      this.options.push(def);
+      for (const flag of flagspec) {
+        if (flag.startsWith("--")) {
+          const flagname = flag.substring(2);
+          this.longOptions[flagname] = def;
+        } else if (flag.startsWith("-")) {
+          const flagname = flag.substring(1);
+          this.shortOptions[flagname] = def;
+        } else {
+          throw Error("option must start with '-' or '--'");
+        }
+      }
+      return this as any;
+    }
+
+    maybeOption<N extends keyof any, V>(
+      name: N,
+      flagspec: string[],
+      conv: Converter<V>,
+      args: OptionArgs<V> = {},
+    ): CommandGroup<GN, TG & SubRecord<GN, N, V | undefined>> {
+      const def: OptionDef = {
+        args: args,
+        conv: conv,
+        flagspec: flagspec,
+        isFlag: false,
+        required: false,
+        name: name as string,
+      };
+      this.options.push(def);
+      for (const flag of flagspec) {
+        if (flag.startsWith("--")) {
+          const flagname = flag.substring(2);
+          this.longOptions[flagname] = def;
+        } else if (flag.startsWith("-")) {
+          const flagname = flag.substring(1);
+          this.shortOptions[flagname] = def;
+        } else {
+          throw Error("option must start with '-' or '--'");
+        }
+      }
+      return this as any;
+    }
+
+    requiredArgument<N extends keyof any, V>(
+      name: N,
+      conv: Converter<V>,
+      args: ArgumentArgs<V> = {},
+    ): CommandGroup<GN, TG & SubRecord<GN, N, V>> {
+      const argDef: ArgumentDef = {
+        args: args,
+        conv: conv,
+        name: name as string,
+        required: true,
+      };
+      this.arguments.push(argDef);
+      return this as any;
+    }
+
+    maybeArgument<N extends keyof any, V>(
+      name: N,
+      conv: Converter<V>,
+      args: ArgumentArgs<V> = {},
+    ): CommandGroup<GN, TG & SubRecord<GN, N, V | undefined>> {
+      const argDef: ArgumentDef = {
+        args: args,
+        conv: conv,
+        name: name as string,
+        required: false,
+      };
+      this.arguments.push(argDef);
+      return this as any;
+    }
+
+    flag<N extends string, V>(
+      name: N,
+      flagspec: string[],
+      args: OptionArgs<V> = {},
+    ): CommandGroup<GN, TG & SubRecord<GN, N, boolean>> {
+      const def: OptionDef = {
+        args: args,
+        flagspec: flagspec,
+        isFlag: true,
+        required: false,
+        name: name as string,
+      };
+      this.options.push(def);
+      for (const flag of flagspec) {
+        if (flag.startsWith("--")) {
+          const flagname = flag.substring(2);
+          this.longOptions[flagname] = def;
+        } else if (flag.startsWith("-")) {
+          const flagname = flag.substring(1);
+          this.shortOptions[flagname] = def;
+        } else {
+          throw Error("option must start with '-' or '--'");
+        }
+      }
+      return this as any;
+    }
+
+    subcommand<GN extends keyof any>(
+      argKey: GN,
+      name: string,
+      args: SubcommandArgs = {},
+    ): CommandGroup<GN, TG> {
+      const cg = new CommandGroup<GN, {}>(argKey as string, name, args);
+      const def: SubcommandDef = {
+        commandGroup: cg,
+        name: name as string,
+        args: args,
+      };
+      cg.flag("help", ["-h", "--help"], {
+        help: "Show this message and exit.",
+      });
+      this.subcommandMap[name as string] = def;
+      this.subcommands.push(def);
+      this.subcommands = this.subcommands.sort((x1, x2) => {
+        const a = x1.name;
+        const b = x2.name;
+        if (a === b) {
+          return 0;
+        } else if (a < b) {
+          return -1;
+        } else {
+          return 1;
+        }
+      });
+      return cg as any;
+    }
+
+    printHelp(progName: string, parents: CommandGroup<any, any>[]): void {
+      let usageSpec = "";
+      for (const p of parents) {
+        usageSpec += (p.name ?? progName) + " ";
+        if (p.arguments.length >= 1) {
+          usageSpec += "<ARGS...> ";
+        }
+      }
+      usageSpec += (this.name ?? progName) + " ";
+      if (this.subcommands.length != 0) {
+        usageSpec += "COMMAND ";
+      }
+      for (const a of this.arguments) {
+        const argName = a.args.metavar ?? a.name;
+        usageSpec += `<${argName}> `;
+      }
+      usageSpec = usageSpec.trimRight();
+      console.log(`Usage: ${usageSpec}`);
+      if (this.scArgs.help) {
+        console.log();
+        console.log(this.scArgs.help);
+      }
+      if (this.options.length != 0) {
+        console.log();
+        console.log("Options:");
+        for (const opt of this.options) {
+          let optSpec = opt.flagspec.join(", ");
+          if (!opt.isFlag) {
+            optSpec = optSpec + "=VALUE";
+          }
+          console.log(formatListing(optSpec, opt.args.help));
+        }
+      }
+
+      if (this.subcommands.length != 0) {
+        console.log();
+        console.log("Commands:");
+        for (const subcmd of this.subcommands) {
+          console.log(formatListing(subcmd.name, subcmd.args.help));
+        }
+      }
+    }
+
+    /**
+     * Run the (sub-)command with the given command line parameters.
+     */
+    run(
+      progname: string,
+      parents: CommandGroup<any, any>[],
+      unparsedArgs: string[],
+      parsedArgs: any,
+    ): void {
+      let posArgIndex = 0;
+      let argsTerminated = false;
+      let i;
+      let foundSubcommand: CommandGroup<any, any> | undefined = undefined;
+      const myArgs: any = (parsedArgs[this.argKey] = {});
+      const foundOptions: { [name: string]: boolean } = {};
+      const currentName = this.name ?? progname;
+      for (i = 0; i < unparsedArgs.length; i++) {
+        const argVal = unparsedArgs[i];
+        if (argsTerminated == false) {
+          if (argVal === "--") {
+            argsTerminated = true;
+            continue;
+          }
+          if (argVal.startsWith("--")) {
+            const opt = argVal.substring(2);
+            const r = splitOpt(opt);
+            const d = this.longOptions[r.key];
+            if (!d) {
+              console.error(
+                `error: unknown option '--${r.key}' for ${currentName}`,
+              );
+              process.exit(-1);
+              throw Error("not reached");
+            }
+            if (d.isFlag) {
+              if (r.value !== undefined) {
+                console.error(`error: flag '--${r.key}' does not take a value`);
+                process.exit(-1);
+                throw Error("not reached");
+              }
+              foundOptions[d.name] = true;
+              myArgs[d.name] = true;
+            } else {
+              if (r.value === undefined) {
+                if (i === unparsedArgs.length - 1) {
+                  console.error(`error: option '--${r.key}' needs an argument`);
+                  process.exit(-1);
+                  throw Error("not reached");
+                }
+                myArgs[d.name] = unparsedArgs[i + 1];
+                i++;
+              } else {
+                myArgs[d.name] = r.value;
+              }
+              foundOptions[d.name] = true;
+            }
+            continue;
+          }
+          if (argVal.startsWith("-") && argVal != "-") {
+            const optShort = argVal.substring(1);
+            for (let si = 0; si < optShort.length; si++) {
+              const chr = optShort[si];
+              const opt = this.shortOptions[chr];
+              if (!opt) {
+                console.error(`error: option '-${chr}' not known`);
+                process.exit(-1);
+              }
+              if (opt.isFlag) {
+                myArgs[opt.name] = true;
+                foundOptions[opt.name] = true;
+              } else {
+                if (si == optShort.length - 1) {
+                  if (i === unparsedArgs.length - 1) {
+                    console.error(`error: option '-${chr}' needs an argument`);
+                    process.exit(-1);
+                    throw Error("not reached");
+                  } else {
+                    myArgs[opt.name] = unparsedArgs[i + 1];
+                    i++;
+                  }
+                } else {
+                  myArgs[opt.name] = optShort.substring(si + 1);
+                }
+                foundOptions[opt.name] = true;
+                break;
+              }
+            }
+            continue;
+          }
+        }
+        if (this.subcommands.length != 0) {
+          const subcmd = this.subcommandMap[argVal];
+          if (!subcmd) {
+            console.error(`error: unknown command '${argVal}'`);
+            process.exit(-1);
+            throw Error("not reached");
+          }
+          foundSubcommand = subcmd.commandGroup;
+          break;
+        } else {
+          const d = this.arguments[posArgIndex];
+          if (!d) {
+            console.error(`error: too many arguments for ${currentName}`);
+            process.exit(-1);
+            throw Error("not reached");
+          }
+          myArgs[d.name] = unparsedArgs[i];
+          posArgIndex++;
+        }
+      }
+
+      if (parsedArgs[this.argKey].help) {
+        this.printHelp(progname, parents);
+        process.exit(0);
+        throw Error("not reached");
+      }
+
+      for (let i = posArgIndex; i < this.arguments.length; i++) {
+        const d = this.arguments[i];
+        if (d.required) {
+          if (d.args.default !== undefined) {
+            myArgs[d.name] = d.args.default;
+          } else {
+            console.error(
+              `error: missing positional argument '${d.name}' for ${currentName}`,
+            );
+            process.exit(-1);
+            throw Error("not reached");
+          }
+        }
+      }
+
+      for (const option of this.options) {
+        if (option.isFlag == false && option.required == true) {
+          if (!foundOptions[option.name]) {
+            if (option.args.default !== undefined) {
+              myArgs[option.name] = option.args.default;
+            } else {
+              const name = option.flagspec.join(",");
+              console.error(`error: missing option '${name}'`);
+              process.exit(-1);
+              throw Error("not reached");
+            }
+          }
+        }
+      }
+
+      for (const option of this.options) {
+        const ph = option.args.onPresentHandler;
+        if (ph && foundOptions[option.name]) {
+          ph(myArgs[option.name]);
+        }
+      }
+
+      if (foundSubcommand) {
+        foundSubcommand.run(
+          progname,
+          Array.prototype.concat(parents, [this]),
+          unparsedArgs.slice(i + 1),
+          parsedArgs,
+        );
+      } else if (this.myAction) {
+        let r;
+        try {
+          r = this.myAction(parsedArgs);
+        } catch (e) {
+          console.error(`An error occurred while running ${currentName}`);
+          console.error(e);
+          process.exit(1);
+        }
+        Promise.resolve(r).catch((e) => {
+          console.error(`An error occurred while running ${currentName}`);
+          console.error(e);
+          process.exit(1);
+        });
+      } else {
+        this.printHelp(progname, parents);
+        process.exit(-1);
+        throw Error("not reached");
+      }
+    }
+  }
+
+  export class Program<PN extends keyof any, T> {
+    private mainCommand: CommandGroup<any, any>;
+
+    constructor(argKey: string, args: ProgramArgs = {}) {
+      this.mainCommand = new CommandGroup<any, any>(argKey, null, {
+        help: args.help,
+      });
+      this.mainCommand.flag("help", ["-h", "--help"], {
+        help: "Show this message and exit.",
+      });
+    }
+
+    run(): void {
+      const args = process.argv;
+      if (args.length < 2) {
+        console.error(
+          "Error while parsing command line arguments: not enough arguments",
+        );
+        process.exit(-1);
+      }
+      const progname = path.basename(args[1]);
+      const rest = args.slice(2);
+
+      this.mainCommand.run(progname, [], rest, {});
+    }
+
+    subcommand<GN extends keyof any>(
+      argKey: GN,
+      name: string,
+      args: SubcommandArgs = {},
+    ): CommandGroup<GN, T> {
+      const cmd = this.mainCommand.subcommand(argKey, name as string, args);
+      return cmd as any;
+    }
+
+    requiredOption<N extends keyof any, V>(
+      name: N,
+      flagspec: string[],
+      conv: Converter<V>,
+      args: OptionArgs<V> = {},
+    ): Program<PN, T & SubRecord<PN, N, V>> {
+      this.mainCommand.requiredOption(name, flagspec, conv, args);
+      return this as any;
+    }
+
+    maybeOption<N extends keyof any, V>(
+      name: N,
+      flagspec: string[],
+      conv: Converter<V>,
+      args: OptionArgs<V> = {},
+    ): Program<PN, T & SubRecord<PN, N, V | undefined>> {
+      this.mainCommand.maybeOption(name, flagspec, conv, args);
+      return this as any;
+    }
+
+    /**
+     * Add a flag (option without value) to the program.
+     */
+    flag<N extends string>(
+      name: N,
+      flagspec: string[],
+      args: OptionArgs<boolean> = {},
+    ): Program<PN, T & SubRecord<PN, N, boolean>> {
+      this.mainCommand.flag(name, flagspec, args);
+      return this as any;
+    }
+
+    /**
+     * Add a required positional argument to the program.
+     */
+    requiredArgument<N extends keyof any, V>(
+      name: N,
+      conv: Converter<V>,
+      args: ArgumentArgs<V> = {},
+    ): Program<PN, T & SubRecord<PN, N, V>> {
+      this.mainCommand.requiredArgument(name, conv, args);
+      return this as any;
+    }
+
+    /**
+     * Add an optional argument to the program.
+     */
+    maybeArgument<N extends keyof any, V>(
+      name: N,
+      conv: Converter<V>,
+      args: ArgumentArgs<V> = {},
+    ): Program<PN, T & SubRecord<PN, N, V | undefined>> {
+      this.mainCommand.maybeArgument(name, conv, args);
+      return this as any;
+    }
+
+    action(f: ActionFn<T>): void {
+      this.mainCommand.action(f);
+    }
+  }
+
+  export type GetArgType<T> = T extends Program<any, infer AT>
+    ? AT
+    : T extends CommandGroup<any, infer AT>
+    ? AT
+    : any;
+
+  export function program<PN extends keyof any>(
+    argKey: PN,
+    args: ProgramArgs = {},
+  ): Program<PN, {}> {
+    return new Program(argKey as string, args);
+  }
+
+  export function prompt(question: string): Promise<string> {
+    const stdinReadline = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    return new Promise<string>((resolve, reject) => {
+      stdinReadline.question(question, (res) => {
+        resolve(res);
+        stdinReadline.close();
+      });
+    });
+  }
+}
diff --git a/packages/taler-util/src/index.node.ts b/packages/taler-util/src/index.node.ts
index 018b4767f..bd59f320a 100644
--- a/packages/taler-util/src/index.node.ts
+++ b/packages/taler-util/src/index.node.ts
@@ -21,3 +21,4 @@ initNodePrng();
 export * from "./index.js";
 export * from "./talerconfig.js";
 export * from "./globbing/minimatch.js";
+export { clk } from "./clk.js";
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e22c3067a..ed921a04c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,32 +4,48 @@ importers:
 
   .:
     specifiers:
-      '@linaria/esbuild': ^3.0.0-beta.7
-      '@linaria/shaker': ^3.0.0-beta.7
-      esbuild: ^0.12.21
+      '@linaria/esbuild': ^3.0.0-beta.13
+      '@linaria/shaker': ^3.0.0-beta.13
+      esbuild: ^0.12.29
     devDependencies:
-      '@linaria/esbuild': 3.0.0-beta.7
-      '@linaria/shaker': 3.0.0-beta.7
-      esbuild: 0.12.21
+      '@linaria/esbuild': 3.0.0-beta.13
+      '@linaria/shaker': 3.0.0-beta.13
+      esbuild: 0.12.29
 
   packages/anastasis-core:
     specifiers:
       '@gnu-taler/taler-util': workspace:^0.8.3
+      '@rollup/plugin-commonjs': ^21.0.1
+      '@rollup/plugin-json': ^4.1.0
+      '@rollup/plugin-node-resolve': ^13.0.6
       ava: ^3.15.0
       fetch-ponyfill: ^7.1.0
       fflate: ^0.6.0
       hash-wasm: ^4.9.0
       node-fetch: ^3.0.0
-      typescript: ^4.4.3
+      rimraf: ^3.0.2
+      rollup: ^2.59.0
+      rollup-plugin-sourcemaps: ^0.6.3
+      source-map-support: ^0.5.19
+      tslib: ^2.1.0
+      typescript: ^4.4.4
     dependencies:
       '@gnu-taler/taler-util': link:../taler-util
       fetch-ponyfill: 7.1.0
       fflate: 0.6.0
       hash-wasm: 4.9.0
       node-fetch: 3.0.0
+      tslib: 2.3.1
     devDependencies:
+      '@rollup/plugin-commonjs': 21.0.1_rollup@2.59.0
+      '@rollup/plugin-json': 4.1.0_rollup@2.59.0
+      '@rollup/plugin-node-resolve': 13.0.6_rollup@2.59.0
       ava: 3.15.0
-      typescript: 4.4.3
+      rimraf: 3.0.2
+      rollup: 2.59.0
+      rollup-plugin-sourcemaps: 0.6.3_rollup@2.59.0
+      source-map-support: 0.5.19
+      typescript: 4.4.4
 
   packages/anastasis-webui:
     specifiers:
@@ -449,11 +465,23 @@ packages:
       '@babel/highlight': 7.14.5
     dev: true
 
+  /@babel/code-frame/7.16.0:
+    resolution: {integrity: sha512-IF4EOMEV+bfYwOmNxGzSnjR2EmQod7f1UXOpZM3l4i4o4QNwzjtJAu/HxdjHq0aYBvdqMuQEY1eg0nqW9ZPORA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/highlight': 7.16.0
+    dev: true
+
   /@babel/compat-data/7.15.0:
     resolution: {integrity: sha512-0NqAC1IJE0S0+lL1SWFMxMkz1pKCNCjI4tr2Zx4LJSXxCLAdr6KyArnY+sno5m3yH9g737ygOyPABDsnXkpxiA==}
     engines: {node: '>=6.9.0'}
     dev: true
 
+  /@babel/compat-data/7.16.0:
+    resolution: {integrity: sha512-DGjt2QZse5SGd9nfOSqO4WLJ8NN/oHkijbXbPrxuoJO3oIPJL3TciZs9FX+cOHNiY9E9l0opL8g7BmLe3T+9ew==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
   /@babel/core/7.12.9:
     resolution: {integrity: sha512-gTXYh3M5wb7FRXQy+FErKFAv90BnlOuNn1QkCK2lREoPAjrQCO49+HVSrFoe5uakFAF5eenS75KbO2vQiLrTMQ==}
     engines: {node: '>=6.9.0'}
@@ -533,6 +561,15 @@ packages:
       source-map: 0.5.7
     dev: true
 
+  /@babel/generator/7.16.0:
+    resolution: {integrity: sha512-RR8hUCfRQn9j9RPKEVXo9LiwoxLPYn6hNZlvUOR8tSnaxlD0p0+la00ZP9/SnRt6HchKr+X0fO2r8vrETiJGew==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+      jsesc: 2.5.2
+      source-map: 0.5.7
+    dev: true
+
   /@babel/helper-annotate-as-pure/7.14.5:
     resolution: {integrity: sha512-EivH9EgBIb+G8ij1B2jAwSH36WnGvkQSEC6CkX/6v6ZFlw5fVOHvsgGF4uiEHO2GzMvunZb6tDLQEQSdrdocrA==}
     engines: {node: '>=6.9.0'}
@@ -540,6 +577,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-annotate-as-pure/7.16.0:
+    resolution: {integrity: sha512-ItmYF9vR4zA8cByDocY05o0LGUkp1zhbTQOH1NFyl5xXEqlTJQCEJjieriw+aFpxo16swMxUnUiKS7a/r4vtHg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-builder-binary-assignment-operator-visitor/7.14.5:
     resolution: {integrity: sha512-YTA/Twn0vBXDVGJuAX6PwW7x5zQei1luDDo2Pl6q1qZ7hVNl0RZrhHCQG/ArGpR29Vl7ETiB8eJyrvpuRp300w==}
     engines: {node: '>=6.9.0'}
@@ -548,6 +592,14 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-builder-binary-assignment-operator-visitor/7.16.0:
+    resolution: {integrity: sha512-9KuleLT0e77wFUku6TUkqZzCEymBdtuQQ27MhEKzf9UOOJu3cYj98kyaDAzxpC7lV6DGiZFuC8XqDsq8/Kl6aQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-explode-assignable-expression': 7.16.0
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-compilation-targets/7.15.0:
     resolution: {integrity: sha512-h+/9t0ncd4jfZ8wsdAsoIxSa61qhBYlycXiHWqJaQBCXAhDCMbPRSMTGnZIkkmt1u4ag+UQmuqcILwqKzZ4N2A==}
     engines: {node: '>=6.9.0'}
@@ -586,6 +638,18 @@ packages:
       semver: 6.3.0
     dev: true
 
+  /@babel/helper-compilation-targets/7.16.0:
+    resolution: {integrity: sha512-S7iaOT1SYlqK0sQaCi21RX4+13hmdmnxIEAnQUB/eh7GeAnRjOUgTYpLkUOiRXzD+yog1JxP0qyAQZ7ZxVxLVg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/compat-data': 7.16.0
+      '@babel/helper-validator-option': 7.14.5
+      browserslist: 4.17.5
+      semver: 6.3.0
+    dev: true
+
   /@babel/helper-create-class-features-plugin/7.15.0:
     resolution: {integrity: sha512-MdmDXgvTIi4heDVX/e9EFfeGpugqm9fobBVg/iioE8kueXrOHdRDe36FAY7SnE9xXLVeYCoJR/gdrBEIHRC83Q==}
     engines: {node: '>=6.9.0'}
@@ -636,6 +700,22 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/helper-create-class-features-plugin/7.16.0:
+    resolution: {integrity: sha512-XLwWvqEaq19zFlF5PTgOod4bUA+XbkR4WLQBct1bkzmxJGB0ZEJaoKF4c8cgH9oBtCDuYJ8BP5NB9uFiEgO5QA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.16.0
+      '@babel/helper-function-name': 7.16.0
+      '@babel/helper-member-expression-to-functions': 7.16.0
+      '@babel/helper-optimise-call-expression': 7.16.0
+      '@babel/helper-replace-supers': 7.16.0
+      '@babel/helper-split-export-declaration': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/helper-create-regexp-features-plugin/7.14.5:
     resolution: {integrity: sha512-TLawwqpOErY2HhWbGJ2nZT5wSkR192QpN+nBg1THfBfftrlvOh+WbhrxXCH4q4xJ9Gl16BGPR/48JA+Ryiho/A==}
     engines: {node: '>=6.9.0'}
@@ -668,6 +748,16 @@ packages:
       regexpu-core: 4.7.1
     dev: true
 
+  /@babel/helper-create-regexp-features-plugin/7.16.0:
+    resolution: {integrity: sha512-3DyG0zAFAZKcOp7aVr33ddwkxJ0Z0Jr5V99y3I690eYLpukJsJvAbzTy1ewoCqsML8SbIrjH14Jc/nSQ4TvNPA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.16.0
+      regexpu-core: 4.8.0
+    dev: true
+
   /@babel/helper-define-polyfill-provider/0.1.5_@babel+core@7.15.0:
     resolution: {integrity: sha512-nXuzCSwlJ/WKr8qxzW816gwyT6VZgiJG17zR40fou70yfAcqjoNyTLl/DQ+FExw5Hx5KNqshmN8Ldl/r2N7cTg==}
     peerDependencies:
@@ -739,6 +829,23 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/helper-define-polyfill-provider/0.2.4:
+    resolution: {integrity: sha512-OrpPZ97s+aPi6h2n1OXzdhVis1SGSsMU2aMHgLcOKfsp4/v1NWpx3CWT3lBj5eeBq9cDkPkh+YCfdF7O12uNDQ==}
+    peerDependencies:
+      '@babel/core': ^7.4.0-0
+    dependencies:
+      '@babel/helper-compilation-targets': 7.16.0
+      '@babel/helper-module-imports': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/traverse': 7.16.0
+      debug: 4.3.2
+      lodash.debounce: 4.0.8
+      resolve: 1.20.0
+      semver: 6.3.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/helper-explode-assignable-expression/7.14.5:
     resolution: {integrity: sha512-Htb24gnGJdIGT4vnRKMdoXiOIlqOLmdiUYpAQ0mYfgVT/GDm8GOYhgi4GL+hMKrkiPRohO4ts34ELFsGAPQLDQ==}
     engines: {node: '>=6.9.0'}
@@ -746,6 +853,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-explode-assignable-expression/7.16.0:
+    resolution: {integrity: sha512-Hk2SLxC9ZbcOhLpg/yMznzJ11W++lg5GMbxt1ev6TXUiJB0N42KPC+7w8a+eWGuqDnUYuwStJoZHM7RgmIOaGQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-function-name/7.14.5:
     resolution: {integrity: sha512-Gjna0AsXWfFvrAuX+VKcN/aNNWonizBj39yGwUzVDVTlMYJMK2Wp6xdpy72mfArFq5uK+NOuexfzZlzI1z9+AQ==}
     engines: {node: '>=6.9.0'}
@@ -755,6 +869,15 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-function-name/7.16.0:
+    resolution: {integrity: sha512-BZh4mEk1xi2h4HFjWUXRQX5AEx4rvaZxHgax9gcjdLWdkjsY7MKt5p0otjsg5noXw+pB+clMCjw+aEVYADMjog==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-get-function-arity': 7.16.0
+      '@babel/template': 7.16.0
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-get-function-arity/7.14.5:
     resolution: {integrity: sha512-I1Db4Shst5lewOM4V+ZKJzQ0JGGaZ6VY1jYvMghRjqs6DWgxLCIyFt30GlnKkfUeFLpJt2vzbMVEXVSXlIFYUg==}
     engines: {node: '>=6.9.0'}
@@ -762,6 +885,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-get-function-arity/7.16.0:
+    resolution: {integrity: sha512-ASCquNcywC1NkYh/z7Cgp3w31YW8aojjYIlNg4VeJiHkqyP4AzIvr4qx7pYDb4/s8YcsZWqqOSxgkvjUz1kpDQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-hoist-variables/7.14.5:
     resolution: {integrity: sha512-R1PXiz31Uc0Vxy4OEOm07x0oSjKAdPPCh3tPivn/Eo8cvz6gveAeuyUUPB21Hoiif0uoPQSSdhIPS3352nvdyQ==}
     engines: {node: '>=6.9.0'}
@@ -769,6 +899,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-hoist-variables/7.16.0:
+    resolution: {integrity: sha512-1AZlpazjUR0EQZQv3sgRNfM9mEVWPK3M6vlalczA+EECcPz3XPh6VplbErL5UoMpChhSck5wAJHthlj1bYpcmg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-member-expression-to-functions/7.15.0:
     resolution: {integrity: sha512-Jq8H8U2kYiafuj2xMTPQwkTBnEEdGKpT35lJEQsRRjnG0LW3neucsaMWLgKcwu3OHKNeYugfw+Z20BXBSEs2Lg==}
     engines: {node: '>=6.9.0'}
@@ -776,6 +913,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-member-expression-to-functions/7.16.0:
+    resolution: {integrity: sha512-bsjlBFPuWT6IWhl28EdrQ+gTvSvj5tqVP5Xeftp07SEuz5pLnsXZuDkDD3Rfcxy0IsHmbZ+7B2/9SHzxO0T+sQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-module-imports/7.14.5:
     resolution: {integrity: sha512-SwrNHu5QWS84XlHwGYPDtCxcA0hrSlL2yhWYLgeOc0w7ccOl2qv4s/nARI0aYZW+bSwAL5CukeXA47B/1NKcnQ==}
     engines: {node: '>=6.9.0'}
@@ -783,6 +927,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-module-imports/7.16.0:
+    resolution: {integrity: sha512-kkH7sWzKPq0xt3H1n+ghb4xEMP8k0U7XV3kkB+ZGy69kDk2ySFW1qPi06sjKzFY3t1j6XbJSqr4mF9L7CYVyhg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-module-transforms/7.15.0:
     resolution: {integrity: sha512-RkGiW5Rer7fpXv9m1B3iHIFDZdItnO2/BLfWVW/9q7+KqQSDY5kUfQEbzdXM1MVhJGcugKV7kRrNVzNxmk7NBg==}
     engines: {node: '>=6.9.0'}
@@ -799,6 +950,22 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/helper-module-transforms/7.16.0:
+    resolution: {integrity: sha512-My4cr9ATcaBbmaEa8M0dZNA74cfI6gitvUAskgDtAFmAqyFKDSHQo5YstxPbN+lzHl2D9l/YOEFqb2mtUh4gfA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-module-imports': 7.16.0
+      '@babel/helper-replace-supers': 7.16.0
+      '@babel/helper-simple-access': 7.16.0
+      '@babel/helper-split-export-declaration': 7.16.0
+      '@babel/helper-validator-identifier': 7.15.7
+      '@babel/template': 7.16.0
+      '@babel/traverse': 7.16.0
+      '@babel/types': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/helper-optimise-call-expression/7.14.5:
     resolution: {integrity: sha512-IqiLIrODUOdnPU9/F8ib1Fx2ohlgDhxnIDU7OEVi+kAbEZcyiF7BLU8W6PfvPi9LzztjS7kcbzbmL7oG8kD6VA==}
     engines: {node: '>=6.9.0'}
@@ -806,6 +973,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-optimise-call-expression/7.16.0:
+    resolution: {integrity: sha512-SuI467Gi2V8fkofm2JPnZzB/SUuXoJA5zXe/xzyPP2M04686RzFKFHPK6HDVN6JvWBIEW8tt9hPR7fXdn2Lgpw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-plugin-utils/7.10.4:
     resolution: {integrity: sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==}
     dev: true
@@ -826,6 +1000,17 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/helper-remap-async-to-generator/7.16.0:
+    resolution: {integrity: sha512-MLM1IOMe9aQBqMWxcRw8dcb9jlM86NIw7KA0Wri91Xkfied+dE0QuBFSBjMNvqzmS0OSIDsMNC24dBEkPUi7ew==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.16.0
+      '@babel/helper-wrap-function': 7.16.0
+      '@babel/types': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/helper-replace-supers/7.15.0:
     resolution: {integrity: sha512-6O+eWrhx+HEra/uJnifCwhwMd6Bp5+ZfZeJwbqUTuqkhIT6YcRhiZCOOFChRypOIe0cV46kFrRBlm+t5vHCEaA==}
     engines: {node: '>=6.9.0'}
@@ -838,6 +1023,18 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/helper-replace-supers/7.16.0:
+    resolution: {integrity: sha512-TQxuQfSCdoha7cpRNJvfaYxxxzmbxXw/+6cS7V02eeDYyhxderSoMVALvwupA54/pZcOTtVeJ0xccp1nGWladA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-member-expression-to-functions': 7.16.0
+      '@babel/helper-optimise-call-expression': 7.16.0
+      '@babel/traverse': 7.16.0
+      '@babel/types': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/helper-simple-access/7.14.8:
     resolution: {integrity: sha512-TrFN4RHh9gnWEU+s7JloIho2T76GPwRHhdzOWLqTrMnlas8T9O7ec+oEDNsRXndOmru9ymH9DFrEOxpzPoSbdg==}
     engines: {node: '>=6.9.0'}
@@ -845,6 +1042,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-simple-access/7.16.0:
+    resolution: {integrity: sha512-o1rjBT/gppAqKsYfUdfHq5Rk03lMQrkPHG1OWzHWpLgVXRH4HnMM9Et9CVdIqwkCQlobnGHEJMsgWP/jE1zUiw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-skip-transparent-expression-wrappers/7.14.5:
     resolution: {integrity: sha512-dmqZB7mrb94PZSAOYtr+ZN5qt5owZIAgqtoTuqiFbHFtxgEcmQlRJVI+bO++fciBunXtB6MK7HrzrfcAzIz2NQ==}
     engines: {node: '>=6.9.0'}
@@ -852,6 +1056,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-skip-transparent-expression-wrappers/7.16.0:
+    resolution: {integrity: sha512-+il1gTy0oHwUsBQZyJvukbB4vPMdcYBrFHa0Uc4AizLxbq6BOYC51Rv4tWocX9BLBDLZ4kc6qUFpQ6HRgL+3zw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-split-export-declaration/7.14.5:
     resolution: {integrity: sha512-hprxVPu6e5Kdp2puZUmvOGjaLv9TCe58E/Fl6hRq4YiVQxIcNvuq6uTM2r1mT/oPskuS9CgR+I94sqAYv0NGKA==}
     engines: {node: '>=6.9.0'}
@@ -859,6 +1070,13 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/helper-split-export-declaration/7.16.0:
+    resolution: {integrity: sha512-0YMMRpuDFNGTHNRiiqJX19GjNXA4H0E8jZ2ibccfSxaCogbm3am5WN/2nQNj0YnQwGWM1J06GOcQ2qnh3+0paw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/helper-validator-identifier/7.12.11:
     resolution: {integrity: sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==}
     dev: true
@@ -872,6 +1090,11 @@ packages:
     engines: {node: '>=6.9.0'}
     dev: true
 
+  /@babel/helper-validator-identifier/7.15.7:
+    resolution: {integrity: sha512-K4JvCtQqad9OY2+yTU8w+E82ywk/fe+ELNlt1G8z3bVGlZfn/hOcQQsUhGhW/N+tb3fxK800wLtKOE/aM0m72w==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
   /@babel/helper-validator-option/7.14.5:
     resolution: {integrity: sha512-OX8D5eeX4XwcroVW45NMvoYaIuFI+GQpA2a8Gi+X/U/cDUIRsV37qQfF905F0htTRCREQIB4KqPeaveRJUl3Ow==}
     engines: {node: '>=6.9.0'}
@@ -889,6 +1112,18 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/helper-wrap-function/7.16.0:
+    resolution: {integrity: sha512-VVMGzYY3vkWgCJML+qVLvGIam902mJW0FvT7Avj1zEe0Gn7D93aWdLblYARTxEw+6DhZmtzhBM2zv0ekE5zg1g==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-function-name': 7.16.0
+      '@babel/template': 7.16.0
+      '@babel/traverse': 7.16.0
+      '@babel/types': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/helpers/7.15.3:
     resolution: {integrity: sha512-HwJiz52XaS96lX+28Tnbu31VeFSQJGOeKHJeaEPQlTl7PnlhFElWPj8tUXtqFIzeN86XxXoBr+WFAyK2PPVz6g==}
     engines: {node: '>=6.9.0'}
@@ -925,12 +1160,36 @@ packages:
       js-tokens: 4.0.0
     dev: true
 
+  /@babel/highlight/7.16.0:
+    resolution: {integrity: sha512-t8MH41kUQylBtu2+4IQA3atqevA2lRgqA2wyVB/YiWmsDSuylZZuXOUy9ric30hfzauEFfdsuk/eXTRrGrfd0g==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.15.7
+      chalk: 2.4.2
+      js-tokens: 4.0.0
+    dev: true
+
   /@babel/parser/7.15.3:
     resolution: {integrity: sha512-O0L6v/HvqbdJawj0iBEfVQMc3/6WP+AeOsovsIgBFyJaG+W2w7eqvZB7puddATmWuARlm1SX7DwxJ/JJUnDpEA==}
     engines: {node: '>=6.0.0'}
     hasBin: true
     dev: true
 
+  /@babel/parser/7.16.2:
+    resolution: {integrity: sha512-RUVpT0G2h6rOZwqLDTrKk7ksNv7YpAilTnYe1/Q+eDjxEceRMKVWbCsX7t8h6C1qCFi/1Y8WZjcEPBAFG27GPw==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+    dev: true
+
+  /@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/7.16.2:
+    resolution: {integrity: sha512-h37CvpLSf8gb2lIJ2CgC3t+EjFbi0t8qS7LCS1xcJIlEXE4czlofwaW7W1HA8zpgOCzI9C1nmoqNR1zWkk0pQg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/7.14.5:
     resolution: {integrity: sha512-ZoJS2XCKPBfTmL122iP6NM9dOg+d4lc9fFk3zxc8iDjvt8Pk4+TlsHSKhIPf6X+L5ORCdBzqMZDjL/WHj7WknQ==}
     engines: {node: '>=6.9.0'}
@@ -966,6 +1225,17 @@ packages:
       '@babel/plugin-proposal-optional-chaining': 7.14.5_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/7.16.0:
+    resolution: {integrity: sha512-4tcFwwicpWTrpl9qjf7UsoosaArgImF85AxqCRZlgc3IQDvkUHjJpruXAL58Wmj+T6fypWTC/BakfEkwIL/pwA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.13.0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-skip-transparent-expression-wrappers': 7.16.0
+      '@babel/plugin-proposal-optional-chaining': 7.16.0
+    dev: true
+
   /@babel/plugin-proposal-async-generator-functions/7.14.9:
     resolution: {integrity: sha512-d1lnh+ZnKrFKwtTYdw320+sQWCTwgkB9fmUhNXRADA4akR6wLjaruSGnIEUjpt9HCOwTr4ynFTKu19b7rFRpmw==}
     engines: {node: '>=6.9.0'}
@@ -1007,6 +1277,19 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-proposal-async-generator-functions/7.16.0:
+    resolution: {integrity: sha512-nyYmIo7ZqKsY6P4lnVmBlxp9B3a96CscbLotlsNuktMHahkDwoPYEjXrZHU0Tj844Z9f1IthVxQln57mhkcExw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-remap-async-to-generator': 7.16.0
+      '@babel/plugin-syntax-async-generators': 7.8.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-proposal-class-properties/7.14.5:
     resolution: {integrity: sha512-q/PLpv5Ko4dVc1LYMpCY7RVAAO4uk55qPwrIuJ5QJ8c6cVuAmhu7I/49JOppXL6gXf7ZHzpRVEUZdYoPLM04Gg==}
     engines: {node: '>=6.9.0'}
@@ -1045,6 +1328,18 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-proposal-class-properties/7.16.0:
+    resolution: {integrity: sha512-mCF3HcuZSY9Fcx56Lbn+CGdT44ioBMMvjNVldpKtj8tpniETdLjnxdHI1+sDWXIM1nNt+EanJOZ3IG9lzVjs7A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-create-class-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-proposal-class-static-block/7.14.5:
     resolution: {integrity: sha512-KBAH5ksEnYHCegqseI5N9skTdxgJdmDoAOc0uXa+4QMYKeZD0w5IARh4FMlTNtaHhbB8v+KzMdTgxMMzsIy6Yg==}
     engines: {node: '>=6.9.0'}
@@ -1086,6 +1381,19 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-proposal-class-static-block/7.16.0:
+    resolution: {integrity: sha512-mAy3sdcY9sKAkf3lQbDiv3olOfiLqI51c9DR9b19uMoR2Z6r5pmGl7dfNFqEvqOyqbf1ta4lknK4gc5PJn3mfA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.12.0
+    dependencies:
+      '@babel/helper-create-class-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-class-static-block': 7.14.5
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-proposal-decorators/7.14.5_@babel+core@7.15.0:
     resolution: {integrity: sha512-LYz5nvQcvYeRVjui1Ykn28i+3aUiXwQ/3MGoEy0InTaz1pJo/lAzmIDXX+BQny/oufgHzJ6vnEEiXQ8KZjEVFg==}
     engines: {node: '>=6.9.0'}
@@ -1132,6 +1440,16 @@ packages:
       '@babel/plugin-syntax-dynamic-import': 7.8.3_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-dynamic-import/7.16.0:
+    resolution: {integrity: sha512-QGSA6ExWk95jFQgwz5GQ2Dr95cf7eI7TKutIXXTb7B1gCLTCz5hTjFTQGfLFBBiC5WSNi7udNwWsqbbMh1c4yQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-dynamic-import': 7.8.3
+    dev: true
+
   /@babel/plugin-proposal-export-default-from/7.14.5_@babel+core@7.15.0:
     resolution: {integrity: sha512-T8KZ5abXvKMjF6JcoXjgac3ElmXf0AWzJwi2O/42Jk+HmCky3D9+i1B7NPP1FblyceqTevKeV/9szeikFoaMDg==}
     engines: {node: '>=6.9.0'}
@@ -1175,6 +1493,16 @@ packages:
       '@babel/plugin-syntax-export-namespace-from': 7.8.3_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-export-namespace-from/7.16.0:
+    resolution: {integrity: sha512-CjI4nxM/D+5wCnhD11MHB1AwRSAYeDT+h8gCdcVJZ/OK7+wRzFsf7PFPWVpVpNRkHMmMkQWAHpTq+15IXQ1diA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-export-namespace-from': 7.8.3
+    dev: true
+
   /@babel/plugin-proposal-json-strings/7.14.5:
     resolution: {integrity: sha512-NSq2fczJYKVRIsUJyNxrVUMhB27zb7N7pOFGQOhBKJrChbGcgEAqyZrmZswkPk18VMurEeJAaICbfm57vUeTbQ==}
     engines: {node: '>=6.9.0'}
@@ -1207,6 +1535,16 @@ packages:
       '@babel/plugin-syntax-json-strings': 7.8.3_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-json-strings/7.16.0:
+    resolution: {integrity: sha512-kouIPuiv8mSi5JkEhzApg5Gn6hFyKPnlkO0a9YSzqRurH8wYzSlf6RJdzluAsbqecdW5pBvDJDfyDIUR/vLxvg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-json-strings': 7.8.3
+    dev: true
+
   /@babel/plugin-proposal-logical-assignment-operators/7.14.5:
     resolution: {integrity: sha512-YGn2AvZAo9TwyhlLvCCWxD90Xq8xJ4aSgaX3G5D/8DW94L8aaT+dS5cSP+Z06+rCJERGSr9GxMBZ601xoc2taw==}
     engines: {node: '>=6.9.0'}
@@ -1239,6 +1577,16 @@ packages:
       '@babel/plugin-syntax-logical-assignment-operators': 7.10.4_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-logical-assignment-operators/7.16.0:
+    resolution: {integrity: sha512-pbW0fE30sVTYXXm9lpVQQ/Vc+iTeQKiXlaNRZPPN2A2VdlWyAtsUrsQ3xydSlDW00TFMK7a8m3cDTkBF5WnV3Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4
+    dev: true
+
   /@babel/plugin-proposal-nullish-coalescing-operator/7.14.5:
     resolution: {integrity: sha512-gun/SOnMqjSb98Nkaq2rTKMwervfdAoz6NphdY0vTfuzMfryj+tDGb2n6UkDKwez+Y8PZDhE3D143v6Gepp4Hg==}
     engines: {node: '>=6.9.0'}
@@ -1271,6 +1619,16 @@ packages:
       '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-nullish-coalescing-operator/7.16.0:
+    resolution: {integrity: sha512-3bnHA8CAFm7cG93v8loghDYyQ8r97Qydf63BeYiGgYbjKKB/XP53W15wfRC7dvKfoiJ34f6Rbyyx2btExc8XsQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3
+    dev: true
+
   /@babel/plugin-proposal-numeric-separator/7.14.5:
     resolution: {integrity: sha512-yiclALKe0vyZRZE0pS6RXgjUOt87GWv6FYa5zqj15PvhOGFO69R5DusPlgK/1K5dVnCtegTiWu9UaBSrLLJJBg==}
     engines: {node: '>=6.9.0'}
@@ -1303,6 +1661,16 @@ packages:
       '@babel/plugin-syntax-numeric-separator': 7.10.4_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-numeric-separator/7.16.0:
+    resolution: {integrity: sha512-FAhE2I6mjispy+vwwd6xWPyEx3NYFS13pikDBWUAFGZvq6POGs5eNchw8+1CYoEgBl9n11I3NkzD7ghn25PQ9Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-numeric-separator': 7.10.4
+    dev: true
+
   /@babel/plugin-proposal-object-rest-spread/7.12.1_@babel+core@7.12.9:
     resolution: {integrity: sha512-s6SowJIjzlhx8o7lsFx5zmY4At6CTtDvgNQDdPzkBQucle58A6b/TTeEBYtyDgmcXjUTM+vE8YOGHZzzbc/ioA==}
     peerDependencies:
@@ -1355,6 +1723,19 @@ packages:
       '@babel/plugin-transform-parameters': 7.14.5_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-object-rest-spread/7.16.0:
+    resolution: {integrity: sha512-LU/+jp89efe5HuWJLmMmFG0+xbz+I2rSI7iLc1AlaeSMDMOGzWlc5yJrMN1d04osXN4sSfpo4O+azkBNBes0jg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/compat-data': 7.16.0
+      '@babel/helper-compilation-targets': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3
+      '@babel/plugin-transform-parameters': 7.16.0
+    dev: true
+
   /@babel/plugin-proposal-optional-catch-binding/7.14.5:
     resolution: {integrity: sha512-3Oyiixm0ur7bzO5ybNcZFlmVsygSIQgdOa7cTfOYCMY+wEPAYhZAJxi3mixKFCTCKUhQXuCTtQ1MzrpL3WT8ZQ==}
     engines: {node: '>=6.9.0'}
@@ -1387,6 +1768,16 @@ packages:
       '@babel/plugin-syntax-optional-catch-binding': 7.8.3_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-optional-catch-binding/7.16.0:
+    resolution: {integrity: sha512-kicDo0A/5J0nrsCPbn89mTG3Bm4XgYi0CZtvex9Oyw7gGZE3HXGD0zpQNH+mo+tEfbo8wbmMvJftOwpmPy7aVw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3
+    dev: true
+
   /@babel/plugin-proposal-optional-chaining/7.14.5:
     resolution: {integrity: sha512-ycz+VOzo2UbWNI1rQXxIuMOzrDdHGrI23fRiz/Si2R4kv2XZQ1BK8ccdHwehMKBlcH/joGW/tzrUmo67gbJHlQ==}
     engines: {node: '>=6.9.0'}
@@ -1422,6 +1813,17 @@ packages:
       '@babel/plugin-syntax-optional-chaining': 7.8.3_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-proposal-optional-chaining/7.16.0:
+    resolution: {integrity: sha512-Y4rFpkZODfHrVo70Uaj6cC1JJOt3Pp0MdWSwIKtb8z1/lsjl9AmnB7ErRFV+QNGIfcY1Eruc2UMx5KaRnXjMyg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-skip-transparent-expression-wrappers': 7.16.0
+      '@babel/plugin-syntax-optional-chaining': 7.8.3
+    dev: true
+
   /@babel/plugin-proposal-private-methods/7.14.5:
     resolution: {integrity: sha512-838DkdUA1u+QTCplatfq4B7+1lnDa/+QMI89x5WZHBcnNv+47N8QEj2k9I2MUU9xIv8XJ4XvPCviM/Dj7Uwt9g==}
     engines: {node: '>=6.9.0'}
@@ -1460,6 +1862,18 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-proposal-private-methods/7.16.0:
+    resolution: {integrity: sha512-IvHmcTHDFztQGnn6aWq4t12QaBXTKr1whF/dgp9kz84X6GUcwq9utj7z2wFCUfeOup/QKnOlt2k0zxkGFx9ubg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-create-class-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-proposal-private-property-in-object/7.14.5:
     resolution: {integrity: sha512-62EyfyA3WA0mZiF2e2IV9mc9Ghwxcg8YTu8BS4Wss4Y3PY725OmS9M0qLORbJwLqFtGh+jiE4wAmocK2CTUK2Q==}
     engines: {node: '>=6.9.0'}
@@ -1504,6 +1918,20 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-proposal-private-property-in-object/7.16.0:
+    resolution: {integrity: sha512-3jQUr/HBbMVZmi72LpjQwlZ55i1queL8KcDTQEkAHihttJnAPrcvG9ZNXIfsd2ugpizZo595egYV6xy+pv4Ofw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.16.0
+      '@babel/helper-create-class-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-proposal-unicode-property-regex/7.14.5:
     resolution: {integrity: sha512-6axIeOU5LnY471KenAB9vI8I5j7NQ2d652hIYwVyRfgaZT5UpiqFKCuVXCDMSrU+3VFafnu2c5m3lrWIlr6A5Q==}
     engines: {node: '>=4'}
@@ -1536,6 +1964,16 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-proposal-unicode-property-regex/7.16.0:
+    resolution: {integrity: sha512-ti7IdM54NXv29cA4+bNNKEMS4jLMCbJgl+Drv+FgYy0erJLAxNAIXcNjNjrRZEcWq0xJHsNVwQezskMFpF8N9g==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-create-regexp-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-syntax-async-generators/7.8.4:
     resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
     peerDependencies:
@@ -2043,6 +2481,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-arrow-functions/7.16.0:
+    resolution: {integrity: sha512-vIFb5250Rbh7roWARvCLvIJ/PtAU5Lhv7BtZ1u24COwpI9Ypjsh+bZcKk6rlIyalK+r0jOc1XQ8I4ovNxNrWrA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-async-to-generator/7.14.5:
     resolution: {integrity: sha512-szkbzQ0mNk0rpu76fzDdqSyPu0MuvpXgC+6rz5rpMb5OIRxdmHfQxrktL8CYolL2d8luMCZTR0DpIMIdL27IjA==}
     engines: {node: '>=6.9.0'}
@@ -2084,6 +2531,19 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-async-to-generator/7.16.0:
+    resolution: {integrity: sha512-PbIr7G9kR8tdH6g8Wouir5uVjklETk91GMVSUq+VaOgiinbCkBP6Q7NN/suM/QutZkMJMvcyAriogcYAdhg8Gw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-module-imports': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-remap-async-to-generator': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-block-scoped-functions/7.14.5:
     resolution: {integrity: sha512-dtqWqdWZ5NqBX3KzsVCWfQI3A53Ft5pWFCT2eCVUftWZgjc5DpDponbIF1+c+7cSGk2wN0YK7HGL/ezfRbpKBQ==}
     engines: {node: '>=6.9.0'}
@@ -2113,6 +2573,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-block-scoped-functions/7.16.0:
+    resolution: {integrity: sha512-V14As3haUOP4ZWrLJ3VVx5rCnrYhMSHN/jX7z6FAt5hjRkLsb0snPCmJwSOML5oxkKO4FNoNv7V5hw/y2bjuvg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-block-scoping/7.15.3:
     resolution: {integrity: sha512-nBAzfZwZb4DkaGtOes1Up1nOAp9TDRRFw4XBzBBSG9QK7KVFmYzgj9o9sbPv7TX5ofL4Auq4wZnxCoPnI/lz2Q==}
     engines: {node: '>=6.9.0'}
@@ -2142,6 +2611,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-block-scoping/7.16.0:
+    resolution: {integrity: sha512-27n3l67/R3UrXfizlvHGuTwsRIFyce3D/6a37GRxn28iyTPvNXaW4XvznexRh1zUNLPjbLL22Id0XQElV94ruw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-classes/7.14.9:
     resolution: {integrity: sha512-NfZpTcxU3foGWbl4wxmZ35mTsYJy8oQocbeIMoDAGGFarAmSQlL+LWMkDx/tj6pNotpbX3rltIA4dprgAPOq5A==}
     engines: {node: '>=6.9.0'}
@@ -2195,6 +2673,23 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-classes/7.16.0:
+    resolution: {integrity: sha512-HUxMvy6GtAdd+GKBNYDWCIA776byUQH8zjnfjxwT1P1ARv/wFu8eBDpmXQcLS/IwRtrxIReGiplOwMeyO7nsDQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.16.0
+      '@babel/helper-function-name': 7.16.0
+      '@babel/helper-optimise-call-expression': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-replace-supers': 7.16.0
+      '@babel/helper-split-export-declaration': 7.16.0
+      globals: 11.12.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-computed-properties/7.14.5:
     resolution: {integrity: sha512-pWM+E4283UxaVzLb8UBXv4EIxMovU4zxT1OPnpHJcmnvyY9QbPPTKZfEj31EUvG3/EQRbYAGaYEUZ4yWOBC2xg==}
     engines: {node: '>=6.9.0'}
@@ -2224,6 +2719,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-computed-properties/7.16.0:
+    resolution: {integrity: sha512-63l1dRXday6S8V3WFY5mXJwcRAnPYxvFfTlt67bwV1rTyVTM5zrp0DBBb13Kl7+ehkCVwIZPumPpFP/4u70+Tw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-destructuring/7.14.7:
     resolution: {integrity: sha512-0mDE99nK+kVh3xlc5vKwB6wnP9ecuSj+zQCa/n0voENtP/zymdT4HH6QEb65wjjcbqr1Jb/7z9Qp7TF5FtwYGw==}
     engines: {node: '>=6.9.0'}
@@ -2253,6 +2757,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-destructuring/7.16.0:
+    resolution: {integrity: sha512-Q7tBUwjxLTsHEoqktemHBMtb3NYwyJPTJdM+wDwb0g8PZ3kQUIzNvwD5lPaqW/p54TXBc/MXZu9Jr7tbUEUM8Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-dotall-regex/7.14.5:
     resolution: {integrity: sha512-loGlnBdj02MDsFaHhAIJzh7euK89lBrGIdM9EAtHFo6xKygCUGuuWe07o1oZVk287amtW1n0808sQM99aZt3gw==}
     engines: {node: '>=6.9.0'}
@@ -2285,6 +2798,16 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-dotall-regex/7.16.0:
+    resolution: {integrity: sha512-FXlDZfQeLILfJlC6I1qyEwcHK5UpRCFkaoVyA1nk9A1L1Yu583YO4un2KsLBsu3IJb4CUbctZks8tD9xPQubLw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-create-regexp-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-duplicate-keys/7.14.5:
     resolution: {integrity: sha512-iJjbI53huKbPDAsJ8EmVmvCKeeq21bAze4fu9GBQtSLqfvzj2oRuHVx4ZkDwEhg1htQ+5OBZh/Ab0XDf5iBZ7A==}
     engines: {node: '>=6.9.0'}
@@ -2314,6 +2837,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-duplicate-keys/7.16.0:
+    resolution: {integrity: sha512-LIe2kcHKAZOJDNxujvmp6z3mfN6V9lJxubU4fJIGoQCkKe3Ec2OcbdlYP+vW++4MpxwG0d1wSDOJtQW5kLnkZQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-exponentiation-operator/7.14.5:
     resolution: {integrity: sha512-jFazJhMBc9D27o9jDnIE5ZErI0R0m7PbKXVq77FFvqFbzvTMuv8jaAwLZ5PviOLSFttqKIW0/wxNSDbjLk0tYA==}
     engines: {node: '>=6.9.0'}
@@ -2346,6 +2878,16 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-exponentiation-operator/7.16.0:
+    resolution: {integrity: sha512-OwYEvzFI38hXklsrbNivzpO3fh87skzx8Pnqi4LoSYeav0xHlueSoCJrSgTPfnbyzopo5b3YVAJkFIcUpK2wsw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-builder-binary-assignment-operator-visitor': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-for-of/7.14.5:
     resolution: {integrity: sha512-CfmqxSUZzBl0rSjpoQSFoR9UEj3HzbGuGNL21/iFTmjb5gFggJp3ph0xR1YBhexmLoKRHzgxuFvty2xdSt6gTA==}
     engines: {node: '>=6.9.0'}
@@ -2375,6 +2917,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-for-of/7.16.0:
+    resolution: {integrity: sha512-5QKUw2kO+GVmKr2wMYSATCTTnHyscl6sxFRAY+rvN7h7WB0lcG0o4NoV6ZQU32OZGVsYUsfLGgPQpDFdkfjlJQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-function-name/7.14.5:
     resolution: {integrity: sha512-vbO6kv0fIzZ1GpmGQuvbwwm+O4Cbm2NrPzwlup9+/3fdkuzo1YqOZcXw26+YUJB84Ja7j9yURWposEHLYwxUfQ==}
     engines: {node: '>=6.9.0'}
@@ -2407,6 +2958,16 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-function-name/7.16.0:
+    resolution: {integrity: sha512-lBzMle9jcOXtSOXUpc7tvvTpENu/NuekNJVova5lCCWCV9/U1ho2HH2y0p6mBg8fPm/syEAbfaaemYGOHCY3mg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-function-name': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-literals/7.14.5:
     resolution: {integrity: sha512-ql33+epql2F49bi8aHXxvLURHkxJbSmMKl9J5yHqg4PLtdE6Uc48CH1GS6TQvZ86eoB/ApZXwm7jlA+B3kra7A==}
     engines: {node: '>=6.9.0'}
@@ -2436,6 +2997,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-literals/7.16.0:
+    resolution: {integrity: sha512-gQDlsSF1iv9RU04clgXqRjrPyyoJMTclFt3K1cjLmTKikc0s/6vE3hlDeEVC71wLTRu72Fq7650kABrdTc2wMQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-member-expression-literals/7.14.5:
     resolution: {integrity: sha512-WkNXxH1VXVTKarWFqmso83xl+2V3Eo28YY5utIkbsmXoItO8Q3aZxN4BTS2k0hz9dGUloHK26mJMyQEYfkn/+Q==}
     engines: {node: '>=6.9.0'}
@@ -2465,6 +3035,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-member-expression-literals/7.16.0:
+    resolution: {integrity: sha512-WRpw5HL4Jhnxw8QARzRvwojp9MIE7Tdk3ez6vRyUk1MwgjJN0aNpRoXainLR5SgxmoXx/vsXGZ6OthP6t/RbUg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-modules-amd/7.14.5:
     resolution: {integrity: sha512-3lpOU8Vxmp3roC4vzFpSdEpGUWSMsHFreTWOMMLzel2gNGfHE5UWIh/LN6ghHs2xurUp4jRFYMUIZhuFbody1g==}
     engines: {node: '>=6.9.0'}
@@ -2506,6 +3085,19 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-modules-amd/7.16.0:
+    resolution: {integrity: sha512-rWFhWbCJ9Wdmzln1NmSCqn7P0RAD+ogXG/bd9Kg5c7PKWkJtkiXmYsMBeXjDlzHpVTJ4I/hnjs45zX4dEv81xw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-module-transforms': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      babel-plugin-dynamic-import-node: 2.3.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-modules-commonjs/7.15.0:
     resolution: {integrity: sha512-3H/R9s8cXcOGE8kgMlmjYYC9nqr5ELiPkJn4q0mypBrjhYQoc+5/Maq69vV4xRPWnkzZuwJPf5rArxpB/35Cig==}
     engines: {node: '>=6.9.0'}
@@ -2550,6 +3142,20 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-modules-commonjs/7.16.0:
+    resolution: {integrity: sha512-Dzi+NWqyEotgzk/sb7kgQPJQf7AJkQBWsVp1N6JWc1lBVo0vkElUnGdr1PzUBmfsCCN5OOFya3RtpeHk15oLKQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-module-transforms': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-simple-access': 7.16.0
+      babel-plugin-dynamic-import-node: 2.3.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-modules-systemjs/7.14.5:
     resolution: {integrity: sha512-mNMQdvBEE5DcMQaL5LbzXFMANrQjd2W7FPzg34Y4yEz7dBgdaC+9B84dSO+/1Wba98zoDbInctCDo4JGxz1VYA==}
     engines: {node: '>=6.9.0'}
@@ -2597,6 +3203,21 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-modules-systemjs/7.16.0:
+    resolution: {integrity: sha512-yuGBaHS3lF1m/5R+6fjIke64ii5luRUg97N2wr+z1sF0V+sNSXPxXDdEEL/iYLszsN5VKxVB1IPfEqhzVpiqvg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-hoist-variables': 7.16.0
+      '@babel/helper-module-transforms': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-validator-identifier': 7.15.7
+      babel-plugin-dynamic-import-node: 2.3.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-modules-umd/7.14.5:
     resolution: {integrity: sha512-RfPGoagSngC06LsGUYyM9QWSXZ8MysEjDJTAea1lqRjNECE3y0qIJF/qbvJxc4oA4s99HumIMdXOrd+TdKaAAA==}
     engines: {node: '>=6.9.0'}
@@ -2635,6 +3256,18 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-modules-umd/7.16.0:
+    resolution: {integrity: sha512-nx4f6no57himWiHhxDM5pjwhae5vLpTK2zCnDH8+wNLJy0TVER/LJRHl2bkt6w9Aad2sPD5iNNoUpY3X9sTGDg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-module-transforms': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-named-capturing-groups-regex/7.14.9:
     resolution: {integrity: sha512-l666wCVYO75mlAtGFfyFwnWmIXQm3kSH0C3IRnJqWcZbWkoihyAdDhFm2ZWaxWTqvBvhVFfJjMRQ0ez4oN1yYA==}
     engines: {node: '>=6.9.0'}
@@ -2664,6 +3297,15 @@ packages:
       '@babel/helper-create-regexp-features-plugin': 7.14.5_@babel+core@7.15.0
     dev: true
 
+  /@babel/plugin-transform-named-capturing-groups-regex/7.16.0:
+    resolution: {integrity: sha512-LogN88uO+7EhxWc8WZuQ8vxdSyVGxhkh8WTC3tzlT8LccMuQdA81e9SGV6zY7kY2LjDhhDOFdQVxdGwPyBCnvg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/helper-create-regexp-features-plugin': 7.16.0
+    dev: true
+
   /@babel/plugin-transform-new-target/7.14.5:
     resolution: {integrity: sha512-Nx054zovz6IIRWEB49RDRuXGI4Gy0GMgqG0cII9L3MxqgXz/+rgII+RU58qpo4g7tNEx1jG7rRVH4ihZoP4esQ==}
     engines: {node: '>=6.9.0'}
@@ -2693,6 +3335,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-new-target/7.16.0:
+    resolution: {integrity: sha512-fhjrDEYv2DBsGN/P6rlqakwRwIp7rBGLPbrKxwh7oVt5NNkIhZVOY2GRV+ULLsQri1bDqwDWnU3vhlmx5B2aCw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-object-assign/7.14.5_@babel+core@7.15.0:
     resolution: {integrity: sha512-lvhjk4UN9xJJYB1mI5KC0/o1D5EcJXdbhVe+4fSk08D6ZN+iuAIs7LJC+71h8av9Ew4+uRq9452v9R93SFmQlQ==}
     engines: {node: '>=6.9.0'}
@@ -2741,6 +3392,18 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/plugin-transform-object-super/7.16.0:
+    resolution: {integrity: sha512-fds+puedQHn4cPLshoHcR1DTMN0q1V9ou0mUjm8whx9pGcNvDrVVrgw+KJzzCaiTdaYhldtrUps8DWVMgrSEyg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-replace-supers': 7.16.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/plugin-transform-parameters/7.14.5:
     resolution: {integrity: sha512-Tl7LWdr6HUxTmzQtzuU14SqbgrSKmaR77M0OKyq4njZLQTPfOvzblNKyNkGwOfEFCEx7KeYHQHDI0P3F02IVkA==}
     engines: {node: '>=6.9.0'}
@@ -2780,6 +3443,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-parameters/7.16.0:
+    resolution: {integrity: sha512-XgnQEm1CevKROPx+udOi/8f8TiGhrUWiHiaUCIp47tE0tpFDjzXNTZc9E5CmCwxNjXTWEVqvRfWZYOTFvMa/ZQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-property-literals/7.14.5:
     resolution: {integrity: sha512-r1uilDthkgXW8Z1vJz2dKYLV1tuw2xsbrp3MrZmD99Wh9vsfKoob+JTgri5VUb/JqyKRXotlOtwgu4stIYCmnw==}
     engines: {node: '>=6.9.0'}
@@ -2809,6 +3481,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-property-literals/7.16.0:
+    resolution: {integrity: sha512-XLldD4V8+pOqX2hwfWhgwXzGdnDOThxaNTgqagOcpBgIxbUvpgU2FMvo5E1RyHbk756WYgdbS0T8y0Cj9FKkWQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-react-display-name/7.15.1_@babel+core@7.15.0:
     resolution: {integrity: sha512-yQZ/i/pUCJAHI/LbtZr413S3VT26qNrEm0M5RRxQJA947/YNYwbZbBaXGDrq6CG5QsZycI1VIP6d7pQaBfP+8Q==}
     engines: {node: '>=6.9.0'}
@@ -2920,6 +3601,15 @@ packages:
       regenerator-transform: 0.14.5
     dev: true
 
+  /@babel/plugin-transform-regenerator/7.16.0:
+    resolution: {integrity: sha512-JAvGxgKuwS2PihiSFaDrp94XOzzTUeDeOQlcKzVAyaPap7BnZXK/lvMDiubkPTdotPKOIZq9xWXWnggUMYiExg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      regenerator-transform: 0.14.5
+    dev: true
+
   /@babel/plugin-transform-reserved-words/7.14.5:
     resolution: {integrity: sha512-cv4F2rv1nD4qdexOGsRQXJrOcyb5CrgjUH9PKrrtyhSDBNWGxd0UIitjyJiWagS+EbUGjG++22mGH1Pub8D6Vg==}
     engines: {node: '>=6.9.0'}
@@ -2949,17 +3639,26 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
-  /@babel/plugin-transform-runtime/7.15.0:
-    resolution: {integrity: sha512-sfHYkLGjhzWTq6xsuQ01oEsUYjkHRux9fW1iUA68dC7Qd8BS1Unq4aZ8itmQp95zUzIcyR2EbNMTzAicFj+guw==}
+  /@babel/plugin-transform-reserved-words/7.16.0:
+    resolution: {integrity: sha512-Dgs8NNCehHSvXdhEhln8u/TtJxfVwGYCgP2OOr5Z3Ar+B+zXicEOKNTyc+eca2cuEOMtjW6m9P9ijOt8QdqWkg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/helper-module-imports': 7.14.5
       '@babel/helper-plugin-utils': 7.14.5
-      babel-plugin-polyfill-corejs2: 0.2.2
-      babel-plugin-polyfill-corejs3: 0.2.4
-      babel-plugin-polyfill-regenerator: 0.2.2
+    dev: true
+
+  /@babel/plugin-transform-runtime/7.16.0:
+    resolution: {integrity: sha512-zlPf1/XFn5+vWdve3AAhf+Sxl+MVa5VlwTwWgnLx23u4GlatSRQJ3Eoo9vllf0a9il3woQsT4SK+5Z7c06h8ag==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-module-imports': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      babel-plugin-polyfill-corejs2: 0.2.3
+      babel-plugin-polyfill-corejs3: 0.3.0
+      babel-plugin-polyfill-regenerator: 0.2.3
       semver: 6.3.0
     transitivePeerDependencies:
       - supports-color
@@ -2994,6 +3693,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-shorthand-properties/7.16.0:
+    resolution: {integrity: sha512-iVb1mTcD8fuhSv3k99+5tlXu5N0v8/DPm2mO3WACLG6al1CGZH7v09HJyUb1TtYl/Z+KrM6pHSIJdZxP5A+xow==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-spread/7.14.6:
     resolution: {integrity: sha512-Zr0x0YroFJku7n7+/HH3A2eIrGMjbmAIbJSVv0IZ+t3U2WUQUA64S/oeied2e+MaGSjmt4alzBCsK9E8gh+fag==}
     engines: {node: '>=6.9.0'}
@@ -3026,6 +3734,16 @@ packages:
       '@babel/helper-skip-transparent-expression-wrappers': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-spread/7.16.0:
+    resolution: {integrity: sha512-Ao4MSYRaLAQczZVp9/7E7QHsCuK92yHRrmVNRe/SlEJjhzivq0BSn8mEraimL8wizHZ3fuaHxKH0iwzI13GyGg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-skip-transparent-expression-wrappers': 7.16.0
+    dev: true
+
   /@babel/plugin-transform-sticky-regex/7.14.5:
     resolution: {integrity: sha512-Z7F7GyvEMzIIbwnziAZmnSNpdijdr4dWt+FJNBnBLz5mwDFkqIXU9wmBcWWad3QeJF5hMTkRe4dAq2sUZiG+8A==}
     engines: {node: '>=6.9.0'}
@@ -3055,6 +3773,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-sticky-regex/7.16.0:
+    resolution: {integrity: sha512-/ntT2NljR9foobKk4E/YyOSwcGUXtYWv5tinMK/3RkypyNBNdhHUaq6Orw5DWq9ZcNlS03BIlEALFeQgeVAo4Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-template-literals/7.14.5:
     resolution: {integrity: sha512-22btZeURqiepOfuy/VkFr+zStqlujWaarpMErvay7goJS6BWwdd6BY9zQyDLDa4x2S3VugxFb162IZ4m/S/+Gg==}
     engines: {node: '>=6.9.0'}
@@ -3084,6 +3811,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-template-literals/7.16.0:
+    resolution: {integrity: sha512-Rd4Ic89hA/f7xUSJQk5PnC+4so50vBoBfxjdQAdvngwidM8jYIBVxBZ/sARxD4e0yMXRbJVDrYf7dyRtIIKT6Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-typeof-symbol/7.14.5:
     resolution: {integrity: sha512-lXzLD30ffCWseTbMQzrvDWqljvZlHkXU+CnseMhkMNqU1sASnCsz3tSzAaH3vCUXb9PHeUb90ZT1BdFTm1xxJw==}
     engines: {node: '>=6.9.0'}
@@ -3113,6 +3849,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-typeof-symbol/7.16.0:
+    resolution: {integrity: sha512-++V2L8Bdf4vcaHi2raILnptTBjGEFxn5315YU+e8+EqXIucA+q349qWngCLpUYqqv233suJ6NOienIVUpS9cqg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-typescript/7.15.0_@babel+core@7.13.16:
     resolution: {integrity: sha512-WIIEazmngMEEHDaPTx0IZY48SaAmjVWe3TRSX7cmJXn0bEv9midFzAjxiruOWYIVf5iQ10vFx7ASDpgEO08L5w==}
     engines: {node: '>=6.9.0'}
@@ -3170,6 +3915,15 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-unicode-escapes/7.16.0:
+    resolution: {integrity: sha512-VFi4dhgJM7Bpk8lRc5CMaRGlKZ29W9C3geZjt9beuzSUrlJxsNwX7ReLwaL6WEvsOf2EQkyIJEPtF8EXjB/g2A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/plugin-transform-unicode-regex/7.14.5:
     resolution: {integrity: sha512-UygduJpC5kHeCiRw/xDVzC+wj8VaYSoKl5JNVmbP7MadpNinAm3SvZCxZ42H37KZBKztz46YC73i9yV34d0Tzw==}
     engines: {node: '>=6.9.0'}
@@ -3202,6 +3956,16 @@ packages:
       '@babel/helper-plugin-utils': 7.14.5
     dev: true
 
+  /@babel/plugin-transform-unicode-regex/7.16.0:
+    resolution: {integrity: sha512-jHLK4LxhHjvCeZDWyA9c+P9XH1sOxRd1RO9xMtDVRAOND/PczPqizEtVdx4TQF/wyPaewqpT+tgQFYMnN/P94A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-create-regexp-features-plugin': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+    dev: true
+
   /@babel/preset-env/7.15.0:
     resolution: {integrity: sha512-FhEpCNFCcWW3iZLg0L2NPE9UerdtsCR6ZcsGHUX6Om6kbCQeL5QZDqFDmeNHC6/fy6UH3jEge7K4qG5uC9In0Q==}
     engines: {node: '>=6.9.0'}
@@ -3453,6 +4217,90 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/preset-env/7.16.0:
+    resolution: {integrity: sha512-cdTu/W0IrviamtnZiTfixPfIncr2M1VqRrkjzZWlr1B4TVYimCFK5jkyOdP4qw2MrlKHi+b3ORj6x8GoCew8Dg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/compat-data': 7.16.0
+      '@babel/helper-compilation-targets': 7.16.0
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/helper-validator-option': 7.14.5
+      '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.16.2
+      '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.16.0
+      '@babel/plugin-proposal-async-generator-functions': 7.16.0
+      '@babel/plugin-proposal-class-properties': 7.16.0
+      '@babel/plugin-proposal-class-static-block': 7.16.0
+      '@babel/plugin-proposal-dynamic-import': 7.16.0
+      '@babel/plugin-proposal-export-namespace-from': 7.16.0
+      '@babel/plugin-proposal-json-strings': 7.16.0
+      '@babel/plugin-proposal-logical-assignment-operators': 7.16.0
+      '@babel/plugin-proposal-nullish-coalescing-operator': 7.16.0
+      '@babel/plugin-proposal-numeric-separator': 7.16.0
+      '@babel/plugin-proposal-object-rest-spread': 7.16.0
+      '@babel/plugin-proposal-optional-catch-binding': 7.16.0
+      '@babel/plugin-proposal-optional-chaining': 7.16.0
+      '@babel/plugin-proposal-private-methods': 7.16.0
+      '@babel/plugin-proposal-private-property-in-object': 7.16.0
+      '@babel/plugin-proposal-unicode-property-regex': 7.16.0
+      '@babel/plugin-syntax-async-generators': 7.8.4
+      '@babel/plugin-syntax-class-properties': 7.12.13
+      '@babel/plugin-syntax-class-static-block': 7.14.5
+      '@babel/plugin-syntax-dynamic-import': 7.8.3
+      '@babel/plugin-syntax-export-namespace-from': 7.8.3
+      '@babel/plugin-syntax-json-strings': 7.8.3
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3
+      '@babel/plugin-syntax-numeric-separator': 7.10.4
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3
+      '@babel/plugin-syntax-optional-chaining': 7.8.3
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5
+      '@babel/plugin-syntax-top-level-await': 7.14.5
+      '@babel/plugin-transform-arrow-functions': 7.16.0
+      '@babel/plugin-transform-async-to-generator': 7.16.0
+      '@babel/plugin-transform-block-scoped-functions': 7.16.0
+      '@babel/plugin-transform-block-scoping': 7.16.0
+      '@babel/plugin-transform-classes': 7.16.0
+      '@babel/plugin-transform-computed-properties': 7.16.0
+      '@babel/plugin-transform-destructuring': 7.16.0
+      '@babel/plugin-transform-dotall-regex': 7.16.0
+      '@babel/plugin-transform-duplicate-keys': 7.16.0
+      '@babel/plugin-transform-exponentiation-operator': 7.16.0
+      '@babel/plugin-transform-for-of': 7.16.0
+      '@babel/plugin-transform-function-name': 7.16.0
+      '@babel/plugin-transform-literals': 7.16.0
+      '@babel/plugin-transform-member-expression-literals': 7.16.0
+      '@babel/plugin-transform-modules-amd': 7.16.0
+      '@babel/plugin-transform-modules-commonjs': 7.16.0
+      '@babel/plugin-transform-modules-systemjs': 7.16.0
+      '@babel/plugin-transform-modules-umd': 7.16.0
+      '@babel/plugin-transform-named-capturing-groups-regex': 7.16.0
+      '@babel/plugin-transform-new-target': 7.16.0
+      '@babel/plugin-transform-object-super': 7.16.0
+      '@babel/plugin-transform-parameters': 7.16.0
+      '@babel/plugin-transform-property-literals': 7.16.0
+      '@babel/plugin-transform-regenerator': 7.16.0
+      '@babel/plugin-transform-reserved-words': 7.16.0
+      '@babel/plugin-transform-shorthand-properties': 7.16.0
+      '@babel/plugin-transform-spread': 7.16.0
+      '@babel/plugin-transform-sticky-regex': 7.16.0
+      '@babel/plugin-transform-template-literals': 7.16.0
+      '@babel/plugin-transform-typeof-symbol': 7.16.0
+      '@babel/plugin-transform-unicode-escapes': 7.16.0
+      '@babel/plugin-transform-unicode-regex': 7.16.0
+      '@babel/preset-modules': 0.1.5
+      '@babel/types': 7.16.0
+      babel-plugin-polyfill-corejs2: 0.2.3
+      babel-plugin-polyfill-corejs3: 0.3.0
+      babel-plugin-polyfill-regenerator: 0.2.3
+      core-js-compat: 3.19.0
+      semver: 6.3.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/preset-modules/0.1.4:
     resolution: {integrity: sha512-J36NhwnfdzpmH41M1DrnkkgAqhZaqr/NBdPfQ677mLzlaXo+oDiv1deyCDtgAhz8p328otdob0Du7+xgHGZbKg==}
     peerDependencies:
@@ -3491,6 +4339,18 @@ packages:
       esutils: 2.0.3
     dev: true
 
+  /@babel/preset-modules/0.1.5:
+    resolution: {integrity: sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-plugin-utils': 7.14.5
+      '@babel/plugin-proposal-unicode-property-regex': 7.16.0
+      '@babel/plugin-transform-dotall-regex': 7.16.0
+      '@babel/types': 7.16.0
+      esutils: 2.0.3
+    dev: true
+
   /@babel/preset-react/7.14.5_@babel+core@7.15.0:
     resolution: {integrity: sha512-XFxBkjyObLvBaAvkx1Ie95Iaq4S/GUEIrejyrntQ/VCMKUYvKLoyKxOBzJ2kjA3b6rC9/KL6KXfDC2GqvLiNqQ==}
     engines: {node: '>=6.9.0'}
@@ -3568,6 +4428,13 @@ packages:
     dependencies:
       regenerator-runtime: 0.13.9
 
+  /@babel/runtime/7.16.0:
+    resolution: {integrity: sha512-Nht8L0O8YCktmsDV6FqFue7vQLRx3Hb0B37lS5y0jDRqRxlBG4wIJHnf9/bgSE2UyipKFA01YtS+npRdTWBUyw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      regenerator-runtime: 0.13.9
+    dev: true
+
   /@babel/template/7.14.5:
     resolution: {integrity: sha512-6Z3Po85sfxRGachLULUhOmvAaOo7xCvqGQtxINai2mEGPFm6pQ4z5QInFnUrRpfoSV60BnjyF5F3c+15fxFV1g==}
     engines: {node: '>=6.9.0'}
@@ -3577,6 +4444,15 @@ packages:
       '@babel/types': 7.15.0
     dev: true
 
+  /@babel/template/7.16.0:
+    resolution: {integrity: sha512-MnZdpFD/ZdYhXwiunMqqgyZyucaYsbL0IrjoGjaVhGilz+x8YB++kRfygSOIj1yOtWKPlx7NBp+9I1RQSgsd5A==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.16.0
+      '@babel/parser': 7.16.2
+      '@babel/types': 7.16.0
+    dev: true
+
   /@babel/traverse/7.15.0:
     resolution: {integrity: sha512-392d8BN0C9eVxVWd8H6x9WfipgVH5IaIoLp23334Sc1vbKKWINnvwRpb4us0xtPaCumlwbTtIYNA0Dv/32sVFw==}
     engines: {node: '>=6.9.0'}
@@ -3594,6 +4470,23 @@ packages:
       - supports-color
     dev: true
 
+  /@babel/traverse/7.16.0:
+    resolution: {integrity: sha512-qQ84jIs1aRQxaGaxSysII9TuDaguZ5yVrEuC0BN2vcPlalwfLovVmCjbFDPECPXcYM/wLvNFfp8uDOliLxIoUQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.16.0
+      '@babel/generator': 7.16.0
+      '@babel/helper-function-name': 7.16.0
+      '@babel/helper-hoist-variables': 7.16.0
+      '@babel/helper-split-export-declaration': 7.16.0
+      '@babel/parser': 7.16.2
+      '@babel/types': 7.16.0
+      debug: 4.3.2
+      globals: 11.12.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@babel/types/7.15.0:
     resolution: {integrity: sha512-OBvfqnllOIdX4ojTHpwZbpvz4j3EWyjkZEdmjH0/cgsd6QOdSgU8rLSk6ard/pcW7rlmjdVSX/AWOaORR1uNOQ==}
     engines: {node: '>=6.9.0'}
@@ -3602,6 +4495,14 @@ packages:
       to-fast-properties: 2.0.0
     dev: true
 
+  /@babel/types/7.16.0:
+    resolution: {integrity: sha512-PJgg/k3SdLsGb3hhisFvtLOw5ts113klrpLuIPtCJIU+BB24fqq6lf8RWqKJEjzqXR9AEH1rIb5XTqwBHB+kQg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.15.7
+      to-fast-properties: 2.0.0
+    dev: true
+
   /@base2/pretty-print-object/1.0.0:
     resolution: {integrity: sha512-4Th98KlMHr5+JkxfcoDT//6vY8vM+iSPrLNpHhRyLx2CFYi8e2RfqPLdpbnpo0Q5lQC5hNB79yes07zb02fvCw==}
     dev: true
@@ -4027,36 +4928,36 @@ packages:
       chalk: 4.1.2
     dev: true
 
-  /@linaria/babel-preset/3.0.0-beta.4_@babel+core@7.13.16:
-    resolution: {integrity: sha512-Bjsk4VZUQXK3u04MuLlyP/+/tDd7bWeLXYCOnq4US9H2QFRdka97fm6hH34SRinoHm9fSPCHrj9d+KtY8ge2wg==}
+  /@linaria/babel-preset/3.0.0-beta.13:
+    resolution: {integrity: sha512-UeurIwmORp1lG+f69bKquRug7ZFVSrQha6TJWvHmGQIFwFx5qpMCXJLhOp2dUpM4y7/NhbKYXqj58RtG3wi4ZQ==}
     peerDependencies:
       '@babel/core': '>=7'
     dependencies:
-      '@babel/core': 7.13.16
-      '@babel/generator': 7.15.0
-      '@babel/plugin-syntax-dynamic-import': 7.8.3_@babel+core@7.13.16
-      '@babel/template': 7.14.5
-      '@linaria/core': 3.0.0-beta.4
+      '@babel/generator': 7.16.0
+      '@babel/plugin-syntax-dynamic-import': 7.8.3
+      '@babel/template': 7.16.0
+      '@linaria/core': 3.0.0-beta.13
       '@linaria/logger': 3.0.0-beta.3
       cosmiconfig: 5.2.1
-      source-map: 0.6.1
+      source-map: 0.7.3
       stylis: 3.5.4
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@linaria/babel-preset/3.0.0-beta.7:
-    resolution: {integrity: sha512-NE5f//T9ywXZA+W+Pw1YjWKdzskUpaV7GVkxXhkxLM2la1+S4xOoZR1rzW77bR1C9GFFwzZTeb8XP85whb2ZqQ==}
+  /@linaria/babel-preset/3.0.0-beta.4_@babel+core@7.13.16:
+    resolution: {integrity: sha512-Bjsk4VZUQXK3u04MuLlyP/+/tDd7bWeLXYCOnq4US9H2QFRdka97fm6hH34SRinoHm9fSPCHrj9d+KtY8ge2wg==}
     peerDependencies:
       '@babel/core': '>=7'
     dependencies:
+      '@babel/core': 7.13.16
       '@babel/generator': 7.15.0
-      '@babel/plugin-syntax-dynamic-import': 7.8.3
+      '@babel/plugin-syntax-dynamic-import': 7.8.3_@babel+core@7.13.16
       '@babel/template': 7.14.5
       '@linaria/core': 3.0.0-beta.4
       '@linaria/logger': 3.0.0-beta.3
       cosmiconfig: 5.2.1
-      source-map: 0.7.3
+      source-map: 0.6.1
       stylis: 3.5.4
     transitivePeerDependencies:
       - supports-color
@@ -4080,17 +4981,21 @@ packages:
       - supports-color
     dev: true
 
+  /@linaria/core/3.0.0-beta.13:
+    resolution: {integrity: sha512-3zEi5plBCOsEzUneRVuQb+2SAx3qaC1dj0FfFAI6zIJQoDWu0dlSwKijMRack7oO9tUWrchfj3OkKQAd1LBdVg==}
+    dev: true
+
   /@linaria/core/3.0.0-beta.4:
     resolution: {integrity: sha512-NzxeMDxRt57nR6tLFZ8xIstp5ld9JQPIyp9+TKtQZhoX3oJuUru+S4vXPr1Gach6VaqKKKT5T6fmJgJl9MMprw==}
     dev: true
 
-  /@linaria/esbuild/3.0.0-beta.7:
-    resolution: {integrity: sha512-ImgwFz/dEe3ea3s4m3QiZV7ssEv8oQVgeMxju0FrkEDg02mWBS8tvU3WTJy0hjb9mUfR8fqJbOZSV33dTrtcww==}
+  /@linaria/esbuild/3.0.0-beta.13:
+    resolution: {integrity: sha512-sHG2KNSQ8G96YdY0WgR8nmB49GOvlCMHCFOg2qV5vRgRgF5BepKenZn5a0f7O2KY+J/sp8NnhGe5YO0bFUeQaQ==}
     peerDependencies:
       '@babel/core': '>=7'
     dependencies:
-      '@linaria/babel-preset': 3.0.0-beta.7
-      esbuild: 0.12.21
+      '@linaria/babel-preset': 3.0.0-beta.13
+      esbuild: 0.12.29
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -4103,12 +5008,12 @@ packages:
       - supports-color
     dev: true
 
-  /@linaria/preeval/3.0.0-beta.7:
-    resolution: {integrity: sha512-fTFgxtjBGKh9P2rsqhBnHTqFo1d8VzznmXKpILM0ClAclVn+FB+KJl+nWyEbQ8nT9/ceRoTwbdZHZ/M3DFHG+w==}
+  /@linaria/preeval/3.0.0-beta.13:
+    resolution: {integrity: sha512-0tia6DHxJ9h3/9LWWxseZw8z2wuB0OHwakQrDFV138m3ym3LwHnRalk9VUpIESnnFOiATya20+drUSx0GRxq/Q==}
     peerDependencies:
       '@babel/core': '>=7'
     dependencies:
-      '@linaria/babel-preset': 3.0.0-beta.7
+      '@linaria/babel-preset': 3.0.0-beta.13
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -4134,19 +5039,20 @@ packages:
       - supports-color
     dev: true
 
-  /@linaria/shaker/3.0.0-beta.7:
-    resolution: {integrity: sha512-fWDbbKcS8EiAnoNhTQa+2Or7QyR3Ofyqjtcrb1aeLN2ecVI2u7B5jAZgVPg9euTnhQ2ieUU3G9hh1INkoGKS/A==}
+  /@linaria/shaker/3.0.0-beta.13:
+    resolution: {integrity: sha512-/ejyBA63pY5OnGK4VxrcD7FxYdQ/weRuPZyy8YEWgh0vVkyeXegwrfupfn+Nt7Lodnej+hrMexloKjxe2NTKfA==}
     peerDependencies:
       '@babel/core': '>=7'
     dependencies:
-      '@babel/generator': 7.15.0
-      '@babel/plugin-transform-runtime': 7.15.0
-      '@babel/plugin-transform-template-literals': 7.14.5
-      '@babel/preset-env': 7.15.0
-      '@linaria/babel-preset': 3.0.0-beta.7
+      '@babel/generator': 7.16.0
+      '@babel/plugin-transform-runtime': 7.16.0
+      '@babel/plugin-transform-template-literals': 7.16.0
+      '@babel/preset-env': 7.16.0
+      '@linaria/babel-preset': 3.0.0-beta.13
       '@linaria/logger': 3.0.0-beta.3
-      '@linaria/preeval': 3.0.0-beta.7
+      '@linaria/preeval': 3.0.0-beta.13
       babel-plugin-transform-react-remove-prop-types: 0.4.24
+      ts-invariant: 0.9.3
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -4507,6 +5413,22 @@ packages:
       rollup: 2.56.2
     dev: true
 
+  /@rollup/plugin-commonjs/21.0.1_rollup@2.59.0:
+    resolution: {integrity: sha512-EA+g22lbNJ8p5kuZJUYyhhDK7WgJckW5g4pNN7n4mAFUM96VuwUnNT3xr2Db2iCZPI1pJPbGyfT5mS9T1dHfMg==}
+    engines: {node: '>= 8.0.0'}
+    peerDependencies:
+      rollup: ^2.38.3
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.59.0
+      commondir: 1.0.1
+      estree-walker: 2.0.2
+      glob: 7.1.7
+      is-reference: 1.2.1
+      magic-string: 0.25.7
+      resolve: 1.20.0
+      rollup: 2.59.0
+    dev: true
+
   /@rollup/plugin-image/2.1.0_rollup@2.56.2:
     resolution: {integrity: sha512-IiRhjv65A4Rb/9R+gTP2JdIciumkc8c+3xFoUfw3PUkX77SqqzvJ028AfX856E3ZdExMrqY9C9ZVXN46w6rh9A==}
     engines: {node: '>= 8.0.0'}
@@ -4545,6 +5467,15 @@ packages:
       rollup: 2.56.2
     dev: true
 
+  /@rollup/plugin-json/4.1.0_rollup@2.59.0:
+    resolution: {integrity: sha512-yfLbTdNS6amI/2OpmbiBoW12vngr5NW2jCJVZSBEz+H5KfUJZ2M7sDjk0U6GOOdCWFVScShte29o9NezJ53TPw==}
+    peerDependencies:
+      rollup: ^1.20.0 || ^2.0.0
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.59.0
+      rollup: 2.59.0
+    dev: true
+
   /@rollup/plugin-node-resolve/11.1.0_rollup@2.37.1:
     resolution: {integrity: sha512-ouBBppRdWJKCllDXGzJ7ZIkYbaq+5TmyP0smt1vdJCFfoZhLi31vhpmjLhyo8lreHf4RoeSNllaWrvSqHpHRog==}
     engines: {node: '>= 10.0.0'}
@@ -4605,6 +5536,21 @@ packages:
       rollup: 2.56.2
     dev: true
 
+  /@rollup/plugin-node-resolve/13.0.6_rollup@2.59.0:
+    resolution: {integrity: sha512-sFsPDMPd4gMqnh2gS0uIxELnoRUp5kBl5knxD2EO0778G1oOJv4G1vyT2cpWz75OU2jDVcXhjVUuTAczGyFNKA==}
+    engines: {node: '>= 10.0.0'}
+    peerDependencies:
+      rollup: ^2.42.0
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.59.0
+      '@types/resolve': 1.17.1
+      builtin-modules: 3.2.0
+      deepmerge: 4.2.2
+      is-module: 1.0.0
+      resolve: 1.20.0
+      rollup: 2.59.0
+    dev: true
+
   /@rollup/plugin-replace/2.3.4_rollup@2.37.1:
     resolution: {integrity: sha512-waBhMzyAtjCL1GwZes2jaE9MjuQ/DQF2BatH3fRivUF3z0JBFrU0U6iBNC/4WR+2rLKhaAhPWDNPYp4mI6RqdQ==}
     peerDependencies:
@@ -4671,6 +5617,18 @@ packages:
       rollup: 2.56.2
     dev: true
 
+  /@rollup/pluginutils/3.1.0_rollup@2.59.0:
+    resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==}
+    engines: {node: '>= 8.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0||^2.0.0
+    dependencies:
+      '@types/estree': 0.0.39
+      estree-walker: 1.0.1
+      picomatch: 2.3.0
+      rollup: 2.59.0
+    dev: true
+
   /@rollup/pluginutils/4.1.1:
     resolution: {integrity: sha512-clDjivHqWGXi7u+0d2r2sBi4Ie6VLEAzWMIkvJLnDmxoOhBYOTfzGbOQBA32THHm11/LiJbd01tJUpJsbshSWQ==}
     engines: {node: '>= 8.0.0'}
@@ -9034,6 +9992,18 @@ packages:
       - supports-color
     dev: true
 
+  /babel-plugin-polyfill-corejs2/0.2.3:
+    resolution: {integrity: sha512-NDZ0auNRzmAfE1oDDPW2JhzIMXUk+FFe2ICejmt5T4ocKgiQx3e0VCRx9NCAidcMtL2RUZaWtXnmjTCkx0tcbA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/compat-data': 7.16.0
+      '@babel/helper-define-polyfill-provider': 0.2.4
+      semver: 6.3.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /babel-plugin-polyfill-corejs3/0.1.7_@babel+core@7.15.0:
     resolution: {integrity: sha512-u+gbS9bbPhZWEeyy1oR/YaaSpod/KDT07arZHb80aTpl8H5ZBq+uN1nN9/xtX7jQyfLdPfoqI4Rue/MQSWJquw==}
     peerDependencies:
@@ -9081,6 +10051,17 @@ packages:
       - supports-color
     dev: true
 
+  /babel-plugin-polyfill-corejs3/0.3.0:
+    resolution: {integrity: sha512-JLwi9vloVdXLjzACL80j24bG6/T1gYxwowG44dg6HN/7aTPdyPbJJidf6ajoA3RPHHtW0j9KMrSOLpIZpAnPpg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-define-polyfill-provider': 0.2.4
+      core-js-compat: 3.19.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /babel-plugin-polyfill-regenerator/0.2.2:
     resolution: {integrity: sha512-Goy5ghsc21HgPDFtzRkSirpZVW35meGoTmTOb2bxqdl60ghub4xOidgNTHaZfQ2FaxQsKmwvXtOAkcIS4SMBWg==}
     peerDependencies:
@@ -9113,6 +10094,16 @@ packages:
       - supports-color
     dev: true
 
+  /babel-plugin-polyfill-regenerator/0.2.3:
+    resolution: {integrity: sha512-JVE78oRZPKFIeUqFGrSORNzQnrDwZR16oiWeGM8ZyjBn2XAT5OjP+wXx5ESuo33nUsFUEJYjtklnsKbxW5L+7g==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/helper-define-polyfill-provider': 0.2.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /babel-plugin-syntax-jsx/6.18.0:
     resolution: {integrity: sha1-CvMqmm4Tyno/1QaeYtew9Y0NiUY=}
     dev: true
@@ -9458,6 +10449,18 @@ packages:
       node-releases: 1.1.75
     dev: true
 
+  /browserslist/4.17.5:
+    resolution: {integrity: sha512-I3ekeB92mmpctWBoLXe0d5wPS2cBuRvvW0JyyJHMrk9/HmP2ZjrTboNAZ8iuGqaEIlKguljbQY32OkOJIRrgoA==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+    dependencies:
+      caniuse-lite: 1.0.30001274
+      electron-to-chromium: 1.3.886
+      escalade: 3.1.1
+      node-releases: 2.0.1
+      picocolors: 1.0.0
+    dev: true
+
   /bser/2.1.1:
     resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
     dependencies:
@@ -9691,6 +10694,10 @@ packages:
     resolution: {integrity: sha512-HOe1r+9VkU4TFmnU70z+r7OLmtR+/chB1rdcJUeQlAinjEeb0cKL20tlAtOagNZhbrtLnCvV19B4FmF1rgzl6A==}
     dev: true
 
+  /caniuse-lite/1.0.30001274:
+    resolution: {integrity: sha512-+Nkvv0fHyhISkiMIjnyjmf5YJcQ1IQHZN6U9TLUMroWR38FNwpsC51Gb68yueafX1V6ifOisInSgP9WJFS13ew==}
+    dev: true
+
   /capture-exit/2.0.0:
     resolution: {integrity: sha512-PiT/hQmTonHhl/HFGN+Lx3JJUznrVYJ3+AQsnthneZbvW7x+f08Tk7yLJTLEOUvBTbduLeeBkxEaYXUOUrRq6g==}
     engines: {node: 6.* || 8.* || >= 10.*}
@@ -10346,6 +11353,13 @@ packages:
       semver: 7.0.0
     dev: true
 
+  /core-js-compat/3.19.0:
+    resolution: {integrity: sha512-R09rKZ56ccGBebjTLZHvzDxhz93YPT37gBm6qUhnwj3Kt7aCjjZWD1injyNbyeFHxNKfeZBSyds6O9n3MKq1sw==}
+    dependencies:
+      browserslist: 4.17.5
+      semver: 7.0.0
+    dev: true
+
   /core-js-pure/3.16.2:
     resolution: {integrity: sha512-oxKe64UH049mJqrKkynWp6Vu0Rlm/BTXO/bJZuN2mmR3RtOFNepLlSWDd1eo16PzHpQAoNG97rLU1V/YxesJjw==}
     requiresBuild: true
@@ -11404,6 +12418,10 @@ packages:
     resolution: {integrity: sha512-YcSRImHt6JZZ2sSuQ4Bzajtk98igQ0iKkksqlzZLzbh4p0OIyJRSvUbsgqfcR8txdfsoYCc4ym306t4p2kP/aw==}
     dev: true
 
+  /electron-to-chromium/1.3.886:
+    resolution: {integrity: sha512-+vYdeBosI63VkCtNWnEVFjgNd/IZwvnsWkKyPtWAvrhA+XfByKoBJcbsMgudVU/bUcGAF9Xp3aXn96voWlc3oQ==}
+    dev: true
+
   /element-resize-detector/1.2.3:
     resolution: {integrity: sha512-+dhNzUgLpq9ol5tyhoG7YLoXL3ssjfFW+0gpszXPwRU6NjGr1fVHMEAF8fVzIiRJq57Nre0RFeIjJwI8Nh2NmQ==}
     dependencies:
@@ -11696,8 +12714,8 @@ packages:
     resolution: {integrity: sha512-EmTr31wppcaIAgblChZiuN/l9Y7DPyw8Xtbg7fIVngn6zMW+IEBJDJngeKC3x6wr0V/vcA2wqeFnaw1bFJbDdA==}
     dev: true
 
-  /esbuild/0.12.21:
-    resolution: {integrity: sha512-7hyXbU3g94aREufI/5nls7Xcc+RGQeZWZApm6hoBaFvt2BPtpT4TjFMQ9Tb1jU8XyBGz00ShmiyflCogphMHFQ==}
+  /esbuild/0.12.29:
+    resolution: {integrity: sha512-w/XuoBCSwepyiZtIRsKsetiLDUVGPVw1E/R3VTFSecIy8UR7Cq3SOtwKHJMFoVqqVG36aGkzh4e8BvpO1Fdc7g==}
     hasBin: true
     requiresBuild: true
     dev: true
@@ -16294,6 +17312,10 @@ packages:
     resolution: {integrity: sha512-Qe5OUajvqrqDSy6wrWFmMwfJ0jVgwiw4T3KqmbTcZ62qW0gQkheXYhcFM1+lOVcGUoRxcEcfyvFMAnDgaF1VWw==}
     dev: true
 
+  /node-releases/2.0.1:
+    resolution: {integrity: sha512-CqyzN6z7Q6aMeF/ktcMVTzhAHCEpf8SOarwpzpf8pNBY2k5/oM34UHldUwp8VKI7uxct2HxSRdJjBaZeESzcxA==}
+    dev: true
+
   /nodent-compiler/3.2.13:
     resolution: {integrity: sha512-nzzWPXZwSdsWie34om+4dLrT/5l1nT/+ig1v06xuSgMtieJVAnMQFuZihUwREM+M7dFso9YoHfDmweexEXXrrw==}
     engines: {'0': n, '1': o, '2': d, '3': e, '4': ' ', '5': '>', '6': '=', '7': ' ', '8': '0', '9': ., '10': '1', '11': '0', '12': ., '13': '0'}
@@ -17054,6 +18076,10 @@ packages:
     resolution: {integrity: sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=}
     dev: true
 
+  /picocolors/1.0.0:
+    resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}
+    dev: true
+
   /picomatch/2.2.2:
     resolution: {integrity: sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==}
     engines: {node: '>=8.6'}
@@ -18891,6 +19917,13 @@ packages:
       regenerate: 1.4.2
     dev: true
 
+  /regenerate-unicode-properties/9.0.0:
+    resolution: {integrity: sha512-3E12UeNSPfjrgwjkR81m5J7Aw/T55Tu7nUyZVQYCKEOs+2dkxEY+DpPtZzO4YruuiPb7NkYLVcyJC4+zCbk5pA==}
+    engines: {node: '>=4'}
+    dependencies:
+      regenerate: 1.4.2
+    dev: true
+
   /regenerate/1.4.2:
     resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==}
     dev: true
@@ -18909,7 +19942,7 @@ packages:
   /regenerator-transform/0.14.5:
     resolution: {integrity: sha512-eOf6vka5IO151Jfsw2NO9WpGX58W6wWmefK3I1zEGr0lOD0u8rwPaNqQL1aRxUaxLeKO3ArNh3VYg1KbaD+FFw==}
     dependencies:
-      '@babel/runtime': 7.15.3
+      '@babel/runtime': 7.16.0
     dev: true
 
   /regex-not/1.0.2:
@@ -18950,6 +19983,18 @@ packages:
       unicode-match-property-value-ecmascript: 1.2.0
     dev: true
 
+  /regexpu-core/4.8.0:
+    resolution: {integrity: sha512-1F6bYsoYiz6is+oz70NWur2Vlh9KWtswuRuzJOfeYUrfPX2o8n74AnUVaOGDbUqVGO9fNHu48/pjJO4sNVwsOg==}
+    engines: {node: '>=4'}
+    dependencies:
+      regenerate: 1.4.2
+      regenerate-unicode-properties: 9.0.0
+      regjsgen: 0.5.2
+      regjsparser: 0.7.0
+      unicode-match-property-ecmascript: 2.0.0
+      unicode-match-property-value-ecmascript: 2.0.0
+    dev: true
+
   /registry-auth-token/4.2.1:
     resolution: {integrity: sha512-6gkSb4U6aWJB4SF2ZvLb76yCBjcvufXBqvvEx1HbmKPkutswjW1xNVRY0+daljIYRbogN7O0etYSlbiaEQyMyw==}
     engines: {node: '>=6.0.0'}
@@ -18975,6 +20020,13 @@ packages:
       jsesc: 0.5.0
     dev: true
 
+  /regjsparser/0.7.0:
+    resolution: {integrity: sha512-A4pcaORqmNMDVwUjWoTzuhwMGpP+NykpfqAsEgI1FSH/EzC7lrN5TMd+kN8YCovX+jMpu8eaqXgXPCa0g8FQNQ==}
+    hasBin: true
+    dependencies:
+      jsesc: 0.5.0
+    dev: true
+
   /relateurl/0.2.7:
     resolution: {integrity: sha1-VNvzd+UUQKypCkzSdGANP/LYiKk=}
     engines: {node: '>= 0.10'}
@@ -19328,6 +20380,21 @@ packages:
       source-map-resolve: 0.6.0
     dev: true
 
+  /rollup-plugin-sourcemaps/0.6.3_rollup@2.59.0:
+    resolution: {integrity: sha512-paFu+nT1xvuO1tPFYXGe+XnQvg4Hjqv/eIhG8i5EspfYYPBKL57X7iVbfv55aNVASg3dzWvES9dmWsL2KhfByw==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      '@types/node': '>=10.0.0'
+      rollup: '>=0.31.2'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.59.0
+      rollup: 2.59.0
+      source-map-resolve: 0.6.0
+    dev: true
+
   /rollup-plugin-terser/7.0.2_rollup@2.37.1:
     resolution: {integrity: sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==}
     peerDependencies:
@@ -19388,6 +20455,14 @@ packages:
       fsevents: 2.3.2
     dev: true
 
+  /rollup/2.59.0:
+    resolution: {integrity: sha512-l7s90JQhCQ6JyZjKgo7Lq1dKh2RxatOM+Jr6a9F7WbS9WgKbocyUSeLmZl8evAse7y96Ae98L2k1cBOwWD8nHw==}
+    engines: {node: '>=10.0.0'}
+    hasBin: true
+    optionalDependencies:
+      fsevents: 2.3.2
+    dev: true
+
   /rst-selector-parser/2.2.3:
     resolution: {integrity: sha1-gbIw6i/MYGbInjRy3nlChdmwPZE=}
     dependencies:
@@ -20927,6 +22002,13 @@ packages:
     resolution: {integrity: sha512-3IVX4nI6B5cc31/GFFE+i8ey/N2eA0CZDbo6n0yrz0zDX8ZJ8djmU1p+XRz7G3is0F3bB3pu2pAroFdAWQKU3w==}
     dev: true
 
+  /ts-invariant/0.9.3:
+    resolution: {integrity: sha512-HinBlTbFslQI0OHP07JLsSXPibSegec6r9ai5xxq/qHYCsIQbzpymLpDhAUsnXcSrDEcd0L62L8vsOEdzM0qlA==}
+    engines: {node: '>=8'}
+    dependencies:
+      tslib: 2.3.1
+    dev: true
+
   /ts-pnp/1.2.0_typescript@4.3.5:
     resolution: {integrity: sha512-csd+vJOb/gkzvcCHgTGSChYpy5f1/XKNsmvBGO4JXS+z1v2HobugDz4s1IeFXM3wZB44uczs+eazB5Q/ccdhQw==}
     engines: {node: '>=6'}
@@ -21137,6 +22219,12 @@ packages:
     hasBin: true
     dev: true
 
+  /typescript/4.4.4:
+    resolution: {integrity: sha512-DqGhF5IKoBl8WNf8C1gu8q0xZSInh9j1kJJMqT3a94w1JzVaBU4EXOSMrz9yDqMT0xt3selp83fuFMQ0uzv6qA==}
+    engines: {node: '>=4.2.0'}
+    hasBin: true
+    dev: true
+
   /uglify-js/3.12.5:
     resolution: {integrity: sha512-SgpgScL4T7Hj/w/GexjnBHi3Ien9WS1Rpfg5y91WXMj9SY997ZCQU76mH4TpLwwfmMvoOU8wiaRkIf6NaH3mtg==}
     engines: {node: '>=0.8.0'}
@@ -21182,6 +22270,11 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
+  /unicode-canonical-property-names-ecmascript/2.0.0:
+    resolution: {integrity: sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==}
+    engines: {node: '>=4'}
+    dev: true
+
   /unicode-match-property-ecmascript/1.0.4:
     resolution: {integrity: sha512-L4Qoh15vTfntsn4P1zqnHulG0LdXgjSO035fEpdtp6YxXhMT51Q6vgM5lYdG/5X3MjS+k/Y9Xw4SFCY9IkR0rg==}
     engines: {node: '>=4'}
@@ -21190,16 +22283,34 @@ packages:
       unicode-property-aliases-ecmascript: 1.1.0
     dev: true
 
+  /unicode-match-property-ecmascript/2.0.0:
+    resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==}
+    engines: {node: '>=4'}
+    dependencies:
+      unicode-canonical-property-names-ecmascript: 2.0.0
+      unicode-property-aliases-ecmascript: 2.0.0
+    dev: true
+
   /unicode-match-property-value-ecmascript/1.2.0:
     resolution: {integrity: sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==}
     engines: {node: '>=4'}
     dev: true
 
+  /unicode-match-property-value-ecmascript/2.0.0:
+    resolution: {integrity: sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==}
+    engines: {node: '>=4'}
+    dev: true
+
   /unicode-property-aliases-ecmascript/1.1.0:
     resolution: {integrity: sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==}
     engines: {node: '>=4'}
     dev: true
 
+  /unicode-property-aliases-ecmascript/2.0.0:
+    resolution: {integrity: sha512-5Zfuy9q/DFr4tfO7ZPeVXb1aPoeQSdeFMLpYuFebehDAhbuevLs5yxSZmIFN1tP5F9Wl4IpJrYojg85/zgyZHQ==}
+    engines: {node: '>=4'}
+    dev: true
+
   /unified/9.2.0:
     resolution: {integrity: sha512-vx2Z0vY+a3YoTj8+pttM3tiJHCwY5UFbYdiWrwBEbHmK8pvsPj2rtAX2BFfgXen8T39CJWblWRDT4L5WGXtDdg==}
     dependencies: