@fluxo-dev/shell-printing 1.0.0 → 25.1.1

package/index.esm.js

@@ -0,0 +1,4271 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import React, { forwardRef, createElement as createElement$1, useState, useEffect, useCallback } from 'react';
+import { DataCard } from '@fluxo-dev/ui-components';
+import { PrintServerType, PrintServerManagedType, FluxoClientSys, PrinterManufacturer, PrinterType } from '@fluxo-dev/api-client-base';
+import { Stack, Text, TextInput, Select, NumberInput, Group, Button, LoadingOverlay, Badge, Menu, ActionIcon, Modal, Center, Drawer, Box, Loader } from '@mantine/core';
+import { showNotification } from '@mantine/notifications';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var check = function (it) {
+  return it && it.Math === Math && it;
+};
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global$e =
+  // eslint-disable-next-line es/no-global-this -- safe
+  check(typeof globalThis == 'object' && globalThis) ||
+  check(typeof window == 'object' && window) ||
+  // eslint-disable-next-line no-restricted-globals -- safe
+  check(typeof self == 'object' && self) ||
+  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+  // eslint-disable-next-line no-new-func -- fallback
+  (function () { return this; })() || Function('return this')();
+
+var objectGetOwnPropertyDescriptor = {};
+
+var fails$d = function (exec) {
+  try {
+    return !!exec();
+  } catch (error) {
+    return true;
+  }
+};
+
+var fails$c = fails$d;
+
+// Detect IE8's incomplete defineProperty implementation
+var descriptors = !fails$c(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
+});
+
+var fails$b = fails$d;
+
+var functionBindNative = !fails$b(function () {
+  // eslint-disable-next-line es/no-function-prototype-bind -- safe
+  var test = (function () { /* empty */ }).bind();
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return typeof test != 'function' || test.hasOwnProperty('prototype');
+});
+
+var NATIVE_BIND$2 = functionBindNative;
+
+var call$b = Function.prototype.call;
+
+var functionCall = NATIVE_BIND$2 ? call$b.bind(call$b) : function () {
+  return call$b.apply(call$b, arguments);
+};
+
+var objectPropertyIsEnumerable = {};
+
+var $propertyIsEnumerable = {}.propertyIsEnumerable;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+// `Object.prototype.propertyIsEnumerable` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+  var descriptor = getOwnPropertyDescriptor$1(this, V);
+  return !!descriptor && descriptor.enumerable;
+} : $propertyIsEnumerable;
+
+var createPropertyDescriptor$4 = function (bitmap, value) {
+  return {
+    enumerable: !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable: !(bitmap & 4),
+    value: value
+  };
+};
+
+var NATIVE_BIND$1 = functionBindNative;
+
+var FunctionPrototype$1 = Function.prototype;
+var call$a = FunctionPrototype$1.call;
+var uncurryThisWithBind = NATIVE_BIND$1 && FunctionPrototype$1.bind.bind(call$a, call$a);
+
+var functionUncurryThis = NATIVE_BIND$1 ? uncurryThisWithBind : function (fn) {
+  return function () {
+    return call$a.apply(fn, arguments);
+  };
+};
+
+var uncurryThis$e = functionUncurryThis;
+
+var toString$5 = uncurryThis$e({}.toString);
+var stringSlice$2 = uncurryThis$e(''.slice);
+
+var classofRaw$2 = function (it) {
+  return stringSlice$2(toString$5(it), 8, -1);
+};
+
+var uncurryThis$d = functionUncurryThis;
+var fails$a = fails$d;
+var classof$3 = classofRaw$2;
+
+var $Object$4 = Object;
+var split = uncurryThis$d(''.split);
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var indexedObject = fails$a(function () {
+  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return !$Object$4('z').propertyIsEnumerable(0);
+}) ? function (it) {
+  return classof$3(it) === 'String' ? split(it, '') : $Object$4(it);
+} : $Object$4;
+
+// we can't use just `it == null` since of `document.all` special case
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+var isNullOrUndefined$3 = function (it) {
+  return it === null || it === undefined;
+};
+
+var isNullOrUndefined$2 = isNullOrUndefined$3;
+
+var $TypeError$a = TypeError;
+
+// `RequireObjectCoercible` abstract operation
+// https://tc39.es/ecma262/#sec-requireobjectcoercible
+var requireObjectCoercible$4 = function (it) {
+  if (isNullOrUndefined$2(it)) throw new $TypeError$a("Can't call method on " + it);
+  return it;
+};
+
+// toObject with fallback for non-array-like ES3 strings
+var IndexedObject = indexedObject;
+var requireObjectCoercible$3 = requireObjectCoercible$4;
+
+var toIndexedObject$5 = function (it) {
+  return IndexedObject(requireObjectCoercible$3(it));
+};
+
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+var documentAll = typeof document == 'object' && document.all;
+
+// `IsCallable` abstract operation
+// https://tc39.es/ecma262/#sec-iscallable
+// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+var isCallable$g = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+  return typeof argument == 'function' || argument === documentAll;
+} : function (argument) {
+  return typeof argument == 'function';
+};
+
+var isCallable$f = isCallable$g;
+
+var isObject$8 = function (it) {
+  return typeof it == 'object' ? it !== null : isCallable$f(it);
+};
+
+var global$d = global$e;
+var isCallable$e = isCallable$g;
+
+var aFunction = function (argument) {
+  return isCallable$e(argument) ? argument : undefined;
+};
+
+var getBuiltIn$3 = function (namespace, method) {
+  return arguments.length < 2 ? aFunction(global$d[namespace]) : global$d[namespace] && global$d[namespace][method];
+};
+
+var uncurryThis$c = functionUncurryThis;
+
+var objectIsPrototypeOf = uncurryThis$c({}.isPrototypeOf);
+
+var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
+
+var global$c = global$e;
+var userAgent = engineUserAgent;
+
+var process$1 = global$c.process;
+var Deno = global$c.Deno;
+var versions = process$1 && process$1.versions || Deno && Deno.version;
+var v8 = versions && versions.v8;
+var match, version;
+
+if (v8) {
+  match = v8.split('.');
+  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+  // but their correct versions are not interesting for us
+  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+}
+
+// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+// so check `userAgent` even if `.v8` exists, but 0
+if (!version && userAgent) {
+  match = userAgent.match(/Edge\/(\d+)/);
+  if (!match || match[1] >= 74) {
+    match = userAgent.match(/Chrome\/(\d+)/);
+    if (match) version = +match[1];
+  }
+}
+
+var engineV8Version = version;
+
+/* eslint-disable es/no-symbol -- required for testing */
+var V8_VERSION = engineV8Version;
+var fails$9 = fails$d;
+var global$b = global$e;
+
+var $String$5 = global$b.String;
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$9(function () {
+  var symbol = Symbol('symbol detection');
+  // Chrome 38 Symbol has incorrect toString conversion
+  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
+  // of course, fail.
+  return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) ||
+    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+});
+
+/* eslint-disable es/no-symbol -- required for testing */
+var NATIVE_SYMBOL$2 = symbolConstructorDetection;
+
+var useSymbolAsUid = NATIVE_SYMBOL$2
+  && !Symbol.sham
+  && typeof Symbol.iterator == 'symbol';
+
+var getBuiltIn$2 = getBuiltIn$3;
+var isCallable$d = isCallable$g;
+var isPrototypeOf$4 = objectIsPrototypeOf;
+var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
+
+var $Object$3 = Object;
+
+var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
+  return typeof it == 'symbol';
+} : function (it) {
+  var $Symbol = getBuiltIn$2('Symbol');
+  return isCallable$d($Symbol) && isPrototypeOf$4($Symbol.prototype, $Object$3(it));
+};
+
+var $String$4 = String;
+
+var tryToString$3 = function (argument) {
+  try {
+    return $String$4(argument);
+  } catch (error) {
+    return 'Object';
+  }
+};
+
+var isCallable$c = isCallable$g;
+var tryToString$2 = tryToString$3;
+
+var $TypeError$9 = TypeError;
+
+// `Assert: IsCallable(argument) is true`
+var aCallable$6 = function (argument) {
+  if (isCallable$c(argument)) return argument;
+  throw new $TypeError$9(tryToString$2(argument) + ' is not a function');
+};
+
+var aCallable$5 = aCallable$6;
+var isNullOrUndefined$1 = isNullOrUndefined$3;
+
+// `GetMethod` abstract operation
+// https://tc39.es/ecma262/#sec-getmethod
+var getMethod$4 = function (V, P) {
+  var func = V[P];
+  return isNullOrUndefined$1(func) ? undefined : aCallable$5(func);
+};
+
+var call$9 = functionCall;
+var isCallable$b = isCallable$g;
+var isObject$7 = isObject$8;
+
+var $TypeError$8 = TypeError;
+
+// `OrdinaryToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+var ordinaryToPrimitive$1 = function (input, pref) {
+  var fn, val;
+  if (pref === 'string' && isCallable$b(fn = input.toString) && !isObject$7(val = call$9(fn, input))) return val;
+  if (isCallable$b(fn = input.valueOf) && !isObject$7(val = call$9(fn, input))) return val;
+  if (pref !== 'string' && isCallable$b(fn = input.toString) && !isObject$7(val = call$9(fn, input))) return val;
+  throw new $TypeError$8("Can't convert object to primitive value");
+};
+
+var sharedStore = {exports: {}};
+
+var isPure = false;
+
+var global$a = global$e;
+
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty$5 = Object.defineProperty;
+
+var defineGlobalProperty$3 = function (key, value) {
+  try {
+    defineProperty$5(global$a, key, { value: value, configurable: true, writable: true });
+  } catch (error) {
+    global$a[key] = value;
+  } return value;
+};
+
+var globalThis$1 = global$e;
+var defineGlobalProperty$2 = defineGlobalProperty$3;
+
+var SHARED = '__core-js_shared__';
+var store$3 = sharedStore.exports = globalThis$1[SHARED] || defineGlobalProperty$2(SHARED, {});
+
+(store$3.versions || (store$3.versions = [])).push({
+  version: '3.36.1',
+  mode: 'global',
+  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
+  license: 'https://github.com/zloirock/core-js/blob/v3.36.1/LICENSE',
+  source: 'https://github.com/zloirock/core-js'
+});
+
+var sharedStoreExports = sharedStore.exports;
+
+var store$2 = sharedStoreExports;
+
+var shared$3 = function (key, value) {
+  return store$2[key] || (store$2[key] = value || {});
+};
+
+var requireObjectCoercible$2 = requireObjectCoercible$4;
+
+var $Object$2 = Object;
+
+// `ToObject` abstract operation
+// https://tc39.es/ecma262/#sec-toobject
+var toObject$2 = function (argument) {
+  return $Object$2(requireObjectCoercible$2(argument));
+};
+
+var uncurryThis$b = functionUncurryThis;
+var toObject$1 = toObject$2;
+
+var hasOwnProperty = uncurryThis$b({}.hasOwnProperty);
+
+// `HasOwnProperty` abstract operation
+// https://tc39.es/ecma262/#sec-hasownproperty
+// eslint-disable-next-line es/no-object-hasown -- safe
+var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+  return hasOwnProperty(toObject$1(it), key);
+};
+
+var uncurryThis$a = functionUncurryThis;
+
+var id = 0;
+var postfix = Math.random();
+var toString$4 = uncurryThis$a(1.0.toString);
+
+var uid$2 = function (key) {
+  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$4(++id + postfix, 36);
+};
+
+var global$9 = global$e;
+var shared$2 = shared$3;
+var hasOwn$b = hasOwnProperty_1;
+var uid$1 = uid$2;
+var NATIVE_SYMBOL$1 = symbolConstructorDetection;
+var USE_SYMBOL_AS_UID = useSymbolAsUid;
+
+var Symbol$2 = global$9.Symbol;
+var WellKnownSymbolsStore = shared$2('wks');
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$2['for'] || Symbol$2 : Symbol$2 && Symbol$2.withoutSetter || uid$1;
+
+var wellKnownSymbol$c = function (name) {
+  if (!hasOwn$b(WellKnownSymbolsStore, name)) {
+    WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$b(Symbol$2, name)
+      ? Symbol$2[name]
+      : createWellKnownSymbol('Symbol.' + name);
+  } return WellKnownSymbolsStore[name];
+};
+
+var call$8 = functionCall;
+var isObject$6 = isObject$8;
+var isSymbol$1 = isSymbol$2;
+var getMethod$3 = getMethod$4;
+var ordinaryToPrimitive = ordinaryToPrimitive$1;
+var wellKnownSymbol$b = wellKnownSymbol$c;
+
+var $TypeError$7 = TypeError;
+var TO_PRIMITIVE = wellKnownSymbol$b('toPrimitive');
+
+// `ToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-toprimitive
+var toPrimitive$1 = function (input, pref) {
+  if (!isObject$6(input) || isSymbol$1(input)) return input;
+  var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
+  var result;
+  if (exoticToPrim) {
+    if (pref === undefined) pref = 'default';
+    result = call$8(exoticToPrim, input, pref);
+    if (!isObject$6(result) || isSymbol$1(result)) return result;
+    throw new $TypeError$7("Can't convert object to primitive value");
+  }
+  if (pref === undefined) pref = 'number';
+  return ordinaryToPrimitive(input, pref);
+};
+
+var toPrimitive = toPrimitive$1;
+var isSymbol = isSymbol$2;
+
+// `ToPropertyKey` abstract operation
+// https://tc39.es/ecma262/#sec-topropertykey
+var toPropertyKey$2 = function (argument) {
+  var key = toPrimitive(argument, 'string');
+  return isSymbol(key) ? key : key + '';
+};
+
+var global$8 = global$e;
+var isObject$5 = isObject$8;
+
+var document$1 = global$8.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS$1 = isObject$5(document$1) && isObject$5(document$1.createElement);
+
+var documentCreateElement$2 = function (it) {
+  return EXISTS$1 ? document$1.createElement(it) : {};
+};
+
+var DESCRIPTORS$b = descriptors;
+var fails$8 = fails$d;
+var createElement = documentCreateElement$2;
+
+// Thanks to IE8 for its funny defineProperty
+var ie8DomDefine = !DESCRIPTORS$b && !fails$8(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty(createElement('div'), 'a', {
+    get: function () { return 7; }
+  }).a !== 7;
+});
+
+var DESCRIPTORS$a = descriptors;
+var call$7 = functionCall;
+var propertyIsEnumerableModule = objectPropertyIsEnumerable;
+var createPropertyDescriptor$3 = createPropertyDescriptor$4;
+var toIndexedObject$4 = toIndexedObject$5;
+var toPropertyKey$1 = toPropertyKey$2;
+var hasOwn$a = hasOwnProperty_1;
+var IE8_DOM_DEFINE$1 = ie8DomDefine;
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+objectGetOwnPropertyDescriptor.f = DESCRIPTORS$a ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
+  O = toIndexedObject$4(O);
+  P = toPropertyKey$1(P);
+  if (IE8_DOM_DEFINE$1) try {
+    return $getOwnPropertyDescriptor$1(O, P);
+  } catch (error) { /* empty */ }
+  if (hasOwn$a(O, P)) return createPropertyDescriptor$3(!call$7(propertyIsEnumerableModule.f, O, P), O[P]);
+};
+
+var objectDefineProperty = {};
+
+var DESCRIPTORS$9 = descriptors;
+var fails$7 = fails$d;
+
+// V8 ~ Chrome 36-
+// https://bugs.chromium.org/p/v8/issues/detail?id=3334
+var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$7(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+    value: 42,
+    writable: false
+  }).prototype !== 42;
+});
+
+var isObject$4 = isObject$8;
+
+var $String$3 = String;
+var $TypeError$6 = TypeError;
+
+// `Assert: Type(argument) is Object`
+var anObject$d = function (argument) {
+  if (isObject$4(argument)) return argument;
+  throw new $TypeError$6($String$3(argument) + ' is not an object');
+};
+
+var DESCRIPTORS$8 = descriptors;
+var IE8_DOM_DEFINE = ie8DomDefine;
+var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
+var anObject$c = anObject$d;
+var toPropertyKey = toPropertyKey$2;
+
+var $TypeError$5 = TypeError;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var $defineProperty = Object.defineProperty;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var ENUMERABLE = 'enumerable';
+var CONFIGURABLE$1 = 'configurable';
+var WRITABLE = 'writable';
+
+// `Object.defineProperty` method
+// https://tc39.es/ecma262/#sec-object.defineproperty
+objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
+  anObject$c(O);
+  P = toPropertyKey(P);
+  anObject$c(Attributes);
+  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+    var current = $getOwnPropertyDescriptor(O, P);
+    if (current && current[WRITABLE]) {
+      O[P] = Attributes.value;
+      Attributes = {
+        configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
+        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+        writable: false
+      };
+    }
+  } return $defineProperty(O, P, Attributes);
+} : $defineProperty : function defineProperty(O, P, Attributes) {
+  anObject$c(O);
+  P = toPropertyKey(P);
+  anObject$c(Attributes);
+  if (IE8_DOM_DEFINE) try {
+    return $defineProperty(O, P, Attributes);
+  } catch (error) { /* empty */ }
+  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$5('Accessors not supported');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};
+
+var DESCRIPTORS$7 = descriptors;
+var definePropertyModule$4 = objectDefineProperty;
+var createPropertyDescriptor$2 = createPropertyDescriptor$4;
+
+var createNonEnumerableProperty$5 = DESCRIPTORS$7 ? function (object, key, value) {
+  return definePropertyModule$4.f(object, key, createPropertyDescriptor$2(1, value));
+} : function (object, key, value) {
+  object[key] = value;
+  return object;
+};
+
+var makeBuiltIn$3 = {exports: {}};
+
+var DESCRIPTORS$6 = descriptors;
+var hasOwn$9 = hasOwnProperty_1;
+
+var FunctionPrototype = Function.prototype;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getDescriptor = DESCRIPTORS$6 && Object.getOwnPropertyDescriptor;
+
+var EXISTS = hasOwn$9(FunctionPrototype, 'name');
+// additional protection from minified / mangled / dropped function names
+var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+var CONFIGURABLE = EXISTS && (!DESCRIPTORS$6 || (DESCRIPTORS$6 && getDescriptor(FunctionPrototype, 'name').configurable));
+
+var functionName = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};
+
+var uncurryThis$9 = functionUncurryThis;
+var isCallable$a = isCallable$g;
+var store$1 = sharedStoreExports;
+
+var functionToString = uncurryThis$9(Function.toString);
+
+// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+if (!isCallable$a(store$1.inspectSource)) {
+  store$1.inspectSource = function (it) {
+    return functionToString(it);
+  };
+}
+
+var inspectSource$1 = store$1.inspectSource;
+
+var global$7 = global$e;
+var isCallable$9 = isCallable$g;
+
+var WeakMap$1 = global$7.WeakMap;
+
+var weakMapBasicDetection = isCallable$9(WeakMap$1) && /native code/.test(String(WeakMap$1));
+
+var shared$1 = shared$3;
+var uid = uid$2;
+
+var keys = shared$1('keys');
+
+var sharedKey$3 = function (key) {
+  return keys[key] || (keys[key] = uid(key));
+};
+
+var hiddenKeys$4 = {};
+
+var NATIVE_WEAK_MAP = weakMapBasicDetection;
+var global$6 = global$e;
+var isObject$3 = isObject$8;
+var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
+var hasOwn$8 = hasOwnProperty_1;
+var shared = sharedStoreExports;
+var sharedKey$2 = sharedKey$3;
+var hiddenKeys$3 = hiddenKeys$4;
+
+var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+var TypeError$1 = global$6.TypeError;
+var WeakMap = global$6.WeakMap;
+var set, get, has$1;
+
+var enforce = function (it) {
+  return has$1(it) ? get(it) : set(it, {});
+};
+
+var getterFor = function (TYPE) {
+  return function (it) {
+    var state;
+    if (!isObject$3(it) || (state = get(it)).type !== TYPE) {
+      throw new TypeError$1('Incompatible receiver, ' + TYPE + ' required');
+    } return state;
+  };
+};
+
+if (NATIVE_WEAK_MAP || shared.state) {
+  var store = shared.state || (shared.state = new WeakMap());
+  /* eslint-disable no-self-assign -- prototype methods protection */
+  store.get = store.get;
+  store.has = store.has;
+  store.set = store.set;
+  /* eslint-enable no-self-assign -- prototype methods protection */
+  set = function (it, metadata) {
+    if (store.has(it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    store.set(it, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return store.get(it) || {};
+  };
+  has$1 = function (it) {
+    return store.has(it);
+  };
+} else {
+  var STATE = sharedKey$2('state');
+  hiddenKeys$3[STATE] = true;
+  set = function (it, metadata) {
+    if (hasOwn$8(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    createNonEnumerableProperty$4(it, STATE, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return hasOwn$8(it, STATE) ? it[STATE] : {};
+  };
+  has$1 = function (it) {
+    return hasOwn$8(it, STATE);
+  };
+}
+
+var internalState = {
+  set: set,
+  get: get,
+  has: has$1,
+  enforce: enforce,
+  getterFor: getterFor
+};
+
+var uncurryThis$8 = functionUncurryThis;
+var fails$6 = fails$d;
+var isCallable$8 = isCallable$g;
+var hasOwn$7 = hasOwnProperty_1;
+var DESCRIPTORS$5 = descriptors;
+var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
+var inspectSource = inspectSource$1;
+var InternalStateModule$2 = internalState;
+
+var enforceInternalState = InternalStateModule$2.enforce;
+var getInternalState$1 = InternalStateModule$2.get;
+var $String$2 = String;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty$4 = Object.defineProperty;
+var stringSlice$1 = uncurryThis$8(''.slice);
+var replace$2 = uncurryThis$8(''.replace);
+var join = uncurryThis$8([].join);
+
+var CONFIGURABLE_LENGTH = DESCRIPTORS$5 && !fails$6(function () {
+  return defineProperty$4(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+});
+
+var TEMPLATE = String(String).split('String');
+
+var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
+  if (stringSlice$1($String$2(name), 0, 7) === 'Symbol(') {
+    name = '[' + replace$2($String$2(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
+  }
+  if (options && options.getter) name = 'get ' + name;
+  if (options && options.setter) name = 'set ' + name;
+  if (!hasOwn$7(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
+    if (DESCRIPTORS$5) defineProperty$4(value, 'name', { value: name, configurable: true });
+    else value.name = name;
+  }
+  if (CONFIGURABLE_LENGTH && options && hasOwn$7(options, 'arity') && value.length !== options.arity) {
+    defineProperty$4(value, 'length', { value: options.arity });
+  }
+  try {
+    if (options && hasOwn$7(options, 'constructor') && options.constructor) {
+      if (DESCRIPTORS$5) defineProperty$4(value, 'prototype', { writable: false });
+    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+    } else if (value.prototype) value.prototype = undefined;
+  } catch (error) { /* empty */ }
+  var state = enforceInternalState(value);
+  if (!hasOwn$7(state, 'source')) {
+    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
+  } return value;
+};
+
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+// eslint-disable-next-line no-extend-native -- required
+Function.prototype.toString = makeBuiltIn$2(function toString() {
+  return isCallable$8(this) && getInternalState$1(this).source || inspectSource(this);
+}, 'toString');
+
+var makeBuiltInExports = makeBuiltIn$3.exports;
+
+var isCallable$7 = isCallable$g;
+var definePropertyModule$3 = objectDefineProperty;
+var makeBuiltIn$1 = makeBuiltInExports;
+var defineGlobalProperty$1 = defineGlobalProperty$3;
+
+var defineBuiltIn$5 = function (O, key, value, options) {
+  if (!options) options = {};
+  var simple = options.enumerable;
+  var name = options.name !== undefined ? options.name : key;
+  if (isCallable$7(value)) makeBuiltIn$1(value, name, options);
+  if (options.global) {
+    if (simple) O[key] = value;
+    else defineGlobalProperty$1(key, value);
+  } else {
+    try {
+      if (!options.unsafe) delete O[key];
+      else if (O[key]) simple = true;
+    } catch (error) { /* empty */ }
+    if (simple) O[key] = value;
+    else definePropertyModule$3.f(O, key, {
+      value: value,
+      enumerable: false,
+      configurable: !options.nonConfigurable,
+      writable: !options.nonWritable
+    });
+  } return O;
+};
+
+var objectGetOwnPropertyNames = {};
+
+var ceil = Math.ceil;
+var floor = Math.floor;
+
+// `Math.trunc` method
+// https://tc39.es/ecma262/#sec-math.trunc
+// eslint-disable-next-line es/no-math-trunc -- safe
+var mathTrunc = Math.trunc || function trunc(x) {
+  var n = +x;
+  return (n > 0 ? floor : ceil)(n);
+};
+
+var trunc = mathTrunc;
+
+// `ToIntegerOrInfinity` abstract operation
+// https://tc39.es/ecma262/#sec-tointegerorinfinity
+var toIntegerOrInfinity$2 = function (argument) {
+  var number = +argument;
+  // eslint-disable-next-line no-self-compare -- NaN check
+  return number !== number || number === 0 ? 0 : trunc(number);
+};
+
+var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
+
+var max = Math.max;
+var min$1 = Math.min;
+
+// Helper for a popular repeating case of the spec:
+// Let integer be ? ToInteger(index).
+// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+var toAbsoluteIndex$1 = function (index, length) {
+  var integer = toIntegerOrInfinity$1(index);
+  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
+};
+
+var toIntegerOrInfinity = toIntegerOrInfinity$2;
+
+var min = Math.min;
+
+// `ToLength` abstract operation
+// https://tc39.es/ecma262/#sec-tolength
+var toLength$1 = function (argument) {
+  var len = toIntegerOrInfinity(argument);
+  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+
+var toLength = toLength$1;
+
+// `LengthOfArrayLike` abstract operation
+// https://tc39.es/ecma262/#sec-lengthofarraylike
+var lengthOfArrayLike$2 = function (obj) {
+  return toLength(obj.length);
+};
+
+var toIndexedObject$3 = toIndexedObject$5;
+var toAbsoluteIndex = toAbsoluteIndex$1;
+var lengthOfArrayLike$1 = lengthOfArrayLike$2;
+
+// `Array.prototype.{ indexOf, includes }` methods implementation
+var createMethod$1 = function (IS_INCLUDES) {
+  return function ($this, el, fromIndex) {
+    var O = toIndexedObject$3($this);
+    var length = lengthOfArrayLike$1(O);
+    if (length === 0) return !IS_INCLUDES && -1;
+    var index = toAbsoluteIndex(fromIndex, length);
+    var value;
+    // Array#includes uses SameValueZero equality algorithm
+    // eslint-disable-next-line no-self-compare -- NaN check
+    if (IS_INCLUDES && el !== el) while (length > index) {
+      value = O[index++];
+      // eslint-disable-next-line no-self-compare -- NaN check
+      if (value !== value) return true;
+    // Array#indexOf ignores holes, Array#includes - not
+    } else for (;length > index; index++) {
+      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+    } return !IS_INCLUDES && -1;
+  };
+};
+
+var arrayIncludes = {
+  // `Array.prototype.includes` method
+  // https://tc39.es/ecma262/#sec-array.prototype.includes
+  includes: createMethod$1(true),
+  // `Array.prototype.indexOf` method
+  // https://tc39.es/ecma262/#sec-array.prototype.indexof
+  indexOf: createMethod$1(false)
+};
+
+var uncurryThis$7 = functionUncurryThis;
+var hasOwn$6 = hasOwnProperty_1;
+var toIndexedObject$2 = toIndexedObject$5;
+var indexOf = arrayIncludes.indexOf;
+var hiddenKeys$2 = hiddenKeys$4;
+
+var push = uncurryThis$7([].push);
+
+var objectKeysInternal = function (object, names) {
+  var O = toIndexedObject$2(object);
+  var i = 0;
+  var result = [];
+  var key;
+  for (key in O) !hasOwn$6(hiddenKeys$2, key) && hasOwn$6(O, key) && push(result, key);
+  // Don't enum bug & hidden keys
+  while (names.length > i) if (hasOwn$6(O, key = names[i++])) {
+    ~indexOf(result, key) || push(result, key);
+  }
+  return result;
+};
+
+// IE8- don't enum bug keys
+var enumBugKeys$3 = [
+  'constructor',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toLocaleString',
+  'toString',
+  'valueOf'
+];
+
+var internalObjectKeys$1 = objectKeysInternal;
+var enumBugKeys$2 = enumBugKeys$3;
+
+var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
+
+// `Object.getOwnPropertyNames` method
+// https://tc39.es/ecma262/#sec-object.getownpropertynames
+// eslint-disable-next-line es/no-object-getownpropertynames -- safe
+objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+  return internalObjectKeys$1(O, hiddenKeys$1);
+};
+
+var objectGetOwnPropertySymbols = {};
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
+
+var getBuiltIn$1 = getBuiltIn$3;
+var uncurryThis$6 = functionUncurryThis;
+var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
+var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
+var anObject$b = anObject$d;
+
+var concat = uncurryThis$6([].concat);
+
+// all object keys, includes non-enumerable and symbols
+var ownKeys$1 = getBuiltIn$1('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = getOwnPropertyNamesModule.f(anObject$b(it));
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+var hasOwn$5 = hasOwnProperty_1;
+var ownKeys = ownKeys$1;
+var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
+var definePropertyModule$2 = objectDefineProperty;
+
+var copyConstructorProperties$2 = function (target, source, exceptions) {
+  var keys = ownKeys(source);
+  var defineProperty = definePropertyModule$2.f;
+  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) {
+      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+    }
+  }
+};
+
+var fails$5 = fails$d;
+var isCallable$6 = isCallable$g;
+
+var replacement = /#|\.prototype\./;
+
+var isForced$1 = function (feature, detection) {
+  var value = data[normalize(feature)];
+  return value === POLYFILL ? true
+    : value === NATIVE ? false
+    : isCallable$6(detection) ? fails$5(detection)
+    : !!detection;
+};
+
+var normalize = isForced$1.normalize = function (string) {
+  return String(string).replace(replacement, '.').toLowerCase();
+};
+
+var data = isForced$1.data = {};
+var NATIVE = isForced$1.NATIVE = 'N';
+var POLYFILL = isForced$1.POLYFILL = 'P';
+
+var isForced_1 = isForced$1;
+
+var global$5 = global$e;
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
+var defineBuiltIn$4 = defineBuiltIn$5;
+var defineGlobalProperty = defineGlobalProperty$3;
+var copyConstructorProperties$1 = copyConstructorProperties$2;
+var isForced = isForced_1;
+
+/*
+  options.target         - name of the target object
+  options.global         - target is the global object
+  options.stat           - export as static methods of target
+  options.proto          - export as prototype methods of target
+  options.real           - real prototype method for the `pure` version
+  options.forced         - export even if the native feature is available
+  options.bind           - bind methods to the target, required for the `pure` version
+  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
+  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
+  options.sham           - add a flag to not completely full polyfills
+  options.enumerable     - export as enumerable property
+  options.dontCallGetSet - prevent calling a getter on target
+  options.name           - the .name of the function if it does not match the key
+*/
+var _export = function (options, source) {
+  var TARGET = options.target;
+  var GLOBAL = options.global;
+  var STATIC = options.stat;
+  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+  if (GLOBAL) {
+    target = global$5;
+  } else if (STATIC) {
+    target = global$5[TARGET] || defineGlobalProperty(TARGET, {});
+  } else {
+    target = global$5[TARGET] && global$5[TARGET].prototype;
+  }
+  if (target) for (key in source) {
+    sourceProperty = source[key];
+    if (options.dontCallGetSet) {
+      descriptor = getOwnPropertyDescriptor(target, key);
+      targetProperty = descriptor && descriptor.value;
+    } else targetProperty = target[key];
+    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+    // contained in target
+    if (!FORCED && targetProperty !== undefined) {
+      if (typeof sourceProperty == typeof targetProperty) continue;
+      copyConstructorProperties$1(sourceProperty, targetProperty);
+    }
+    // add a flag to not completely full polyfills
+    if (options.sham || (targetProperty && targetProperty.sham)) {
+      createNonEnumerableProperty$3(sourceProperty, 'sham', true);
+    }
+    defineBuiltIn$4(target, key, sourceProperty, options);
+  }
+};
+
+var wellKnownSymbol$a = wellKnownSymbol$c;
+
+var TO_STRING_TAG$4 = wellKnownSymbol$a('toStringTag');
+var test = {};
+
+test[TO_STRING_TAG$4] = 'z';
+
+var toStringTagSupport = String(test) === '[object z]';
+
+var TO_STRING_TAG_SUPPORT = toStringTagSupport;
+var isCallable$5 = isCallable$g;
+var classofRaw$1 = classofRaw$2;
+var wellKnownSymbol$9 = wellKnownSymbol$c;
+
+var TO_STRING_TAG$3 = wellKnownSymbol$9('toStringTag');
+var $Object$1 = Object;
+
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+  try {
+    return it[key];
+  } catch (error) { /* empty */ }
+};
+
+// getting tag from ES6+ `Object.prototype.toString`
+var classof$2 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
+  var O, tag, result;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$3)) == 'string' ? tag
+    // builtinTag case
+    : CORRECT_ARGUMENTS ? classofRaw$1(O)
+    // ES3 arguments fallback
+    : (result = classofRaw$1(O)) === 'Object' && isCallable$5(O.callee) ? 'Arguments' : result;
+};
+
+var classof$1 = classof$2;
+
+var $String$1 = String;
+
+var toString$3 = function (argument) {
+  if (classof$1(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
+  return $String$1(argument);
+};
+
+var makeBuiltIn = makeBuiltInExports;
+var defineProperty$3 = objectDefineProperty;
+
+var defineBuiltInAccessor$2 = function (target, name, descriptor) {
+  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
+  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
+  return defineProperty$3.f(target, name, descriptor);
+};
+
+var $$5 = _export;
+var DESCRIPTORS$4 = descriptors;
+var global$4 = global$e;
+var uncurryThis$5 = functionUncurryThis;
+var hasOwn$4 = hasOwnProperty_1;
+var isCallable$4 = isCallable$g;
+var isPrototypeOf$3 = objectIsPrototypeOf;
+var toString$2 = toString$3;
+var defineBuiltInAccessor$1 = defineBuiltInAccessor$2;
+var copyConstructorProperties = copyConstructorProperties$2;
+
+var NativeSymbol = global$4.Symbol;
+var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
+
+if (DESCRIPTORS$4 && isCallable$4(NativeSymbol) && (!('description' in SymbolPrototype) ||
+  // Safari 12 bug
+  NativeSymbol().description !== undefined
+)) {
+  var EmptyStringDescriptionStore = {};
+  // wrap Symbol constructor for correct work with undefined description
+  var SymbolWrapper = function Symbol() {
+    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString$2(arguments[0]);
+    var result = isPrototypeOf$3(SymbolPrototype, this)
+      ? new NativeSymbol(description)
+      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
+      : description === undefined ? NativeSymbol() : NativeSymbol(description);
+    if (description === '') EmptyStringDescriptionStore[result] = true;
+    return result;
+  };
+
+  copyConstructorProperties(SymbolWrapper, NativeSymbol);
+  SymbolWrapper.prototype = SymbolPrototype;
+  SymbolPrototype.constructor = SymbolWrapper;
+
+  var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)';
+  var thisSymbolValue = uncurryThis$5(SymbolPrototype.valueOf);
+  var symbolDescriptiveString = uncurryThis$5(SymbolPrototype.toString);
+  var regexp = /^Symbol\((.*)\)[^)]+$/;
+  var replace$1 = uncurryThis$5(''.replace);
+  var stringSlice = uncurryThis$5(''.slice);
+
+  defineBuiltInAccessor$1(SymbolPrototype, 'description', {
+    configurable: true,
+    get: function description() {
+      var symbol = thisSymbolValue(this);
+      if (hasOwn$4(EmptyStringDescriptionStore, symbol)) return '';
+      var string = symbolDescriptiveString(symbol);
+      var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace$1(string, regexp, '$1');
+      return desc === '' ? undefined : desc;
+    }
+  });
+
+  $$5({ global: true, constructor: true, forced: true }, {
+    Symbol: SymbolWrapper
+  });
+}
+
+var objectDefineProperties = {};
+
+var internalObjectKeys = objectKeysInternal;
+var enumBugKeys$1 = enumBugKeys$3;
+
+// `Object.keys` method
+// https://tc39.es/ecma262/#sec-object.keys
+// eslint-disable-next-line es/no-object-keys -- safe
+var objectKeys$1 = Object.keys || function keys(O) {
+  return internalObjectKeys(O, enumBugKeys$1);
+};
+
+var DESCRIPTORS$3 = descriptors;
+var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
+var definePropertyModule$1 = objectDefineProperty;
+var anObject$a = anObject$d;
+var toIndexedObject$1 = toIndexedObject$5;
+var objectKeys = objectKeys$1;
+
+// `Object.defineProperties` method
+// https://tc39.es/ecma262/#sec-object.defineproperties
+// eslint-disable-next-line es/no-object-defineproperties -- safe
+objectDefineProperties.f = DESCRIPTORS$3 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+  anObject$a(O);
+  var props = toIndexedObject$1(Properties);
+  var keys = objectKeys(Properties);
+  var length = keys.length;
+  var index = 0;
+  var key;
+  while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
+  return O;
+};
+
+var getBuiltIn = getBuiltIn$3;
+
+var html$1 = getBuiltIn('document', 'documentElement');
+
+/* global ActiveXObject -- old IE, WSH */
+var anObject$9 = anObject$d;
+var definePropertiesModule = objectDefineProperties;
+var enumBugKeys = enumBugKeys$3;
+var hiddenKeys = hiddenKeys$4;
+var html = html$1;
+var documentCreateElement$1 = documentCreateElement$2;
+var sharedKey$1 = sharedKey$3;
+
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO$1 = sharedKey$1('IE_PROTO');
+
+var EmptyConstructor = function () { /* empty */ };
+
+var scriptTag = function (content) {
+  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+};
+
+// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+var NullProtoObjectViaActiveX = function (activeXDocument) {
+  activeXDocument.write(scriptTag(''));
+  activeXDocument.close();
+  var temp = activeXDocument.parentWindow.Object;
+  activeXDocument = null; // avoid memory leak
+  return temp;
+};
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var NullProtoObjectViaIFrame = function () {
+  // Thrash, waste and sodomy: IE GC bug
+  var iframe = documentCreateElement$1('iframe');
+  var JS = 'java' + SCRIPT + ':';
+  var iframeDocument;
+  iframe.style.display = 'none';
+  html.appendChild(iframe);
+  // https://github.com/zloirock/core-js/issues/475
+  iframe.src = String(JS);
+  iframeDocument = iframe.contentWindow.document;
+  iframeDocument.open();
+  iframeDocument.write(scriptTag('document.F=Object'));
+  iframeDocument.close();
+  return iframeDocument.F;
+};
+
+// Check for document.domain and active x support
+// No need to use active x approach when document.domain is not set
+// see https://github.com/es-shims/es5-shim/issues/150
+// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+// avoid IE GC bug
+var activeXDocument;
+var NullProtoObject = function () {
+  try {
+    activeXDocument = new ActiveXObject('htmlfile');
+  } catch (error) { /* ignore */ }
+  NullProtoObject = typeof document != 'undefined'
+    ? document.domain && activeXDocument
+      ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+      : NullProtoObjectViaIFrame()
+    : NullProtoObjectViaActiveX(activeXDocument); // WSH
+  var length = enumBugKeys.length;
+  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+  return NullProtoObject();
+};
+
+hiddenKeys[IE_PROTO$1] = true;
+
+// `Object.create` method
+// https://tc39.es/ecma262/#sec-object.create
+// eslint-disable-next-line es/no-object-create -- safe
+var objectCreate = Object.create || function create(O, Properties) {
+  var result;
+  if (O !== null) {
+    EmptyConstructor[PROTOTYPE] = anObject$9(O);
+    result = new EmptyConstructor();
+    EmptyConstructor[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO$1] = O;
+  } else result = NullProtoObject();
+  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
+};
+
+var wellKnownSymbol$8 = wellKnownSymbol$c;
+var create$2 = objectCreate;
+var defineProperty$2 = objectDefineProperty.f;
+
+var UNSCOPABLES = wellKnownSymbol$8('unscopables');
+var ArrayPrototype$1 = Array.prototype;
+
+// Array.prototype[@@unscopables]
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype$1[UNSCOPABLES] === undefined) {
+  defineProperty$2(ArrayPrototype$1, UNSCOPABLES, {
+    configurable: true,
+    value: create$2(null)
+  });
+}
+
+// add a key to Array.prototype[@@unscopables]
+var addToUnscopables$1 = function (key) {
+  ArrayPrototype$1[UNSCOPABLES][key] = true;
+};
+
+var iterators = {};
+
+var fails$4 = fails$d;
+
+var correctPrototypeGetter = !fails$4(function () {
+  function F() { /* empty */ }
+  F.prototype.constructor = null;
+  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+  return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+
+var hasOwn$3 = hasOwnProperty_1;
+var isCallable$3 = isCallable$g;
+var toObject = toObject$2;
+var sharedKey = sharedKey$3;
+var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
+
+var IE_PROTO = sharedKey('IE_PROTO');
+var $Object = Object;
+var ObjectPrototype = $Object.prototype;
+
+// `Object.getPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.getprototypeof
+// eslint-disable-next-line es/no-object-getprototypeof -- safe
+var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
+  var object = toObject(O);
+  if (hasOwn$3(object, IE_PROTO)) return object[IE_PROTO];
+  var constructor = object.constructor;
+  if (isCallable$3(constructor) && object instanceof constructor) {
+    return constructor.prototype;
+  } return object instanceof $Object ? ObjectPrototype : null;
+};
+
+var fails$3 = fails$d;
+var isCallable$2 = isCallable$g;
+var isObject$2 = isObject$8;
+var getPrototypeOf$2 = objectGetPrototypeOf;
+var defineBuiltIn$3 = defineBuiltIn$5;
+var wellKnownSymbol$7 = wellKnownSymbol$c;
+
+var ITERATOR$6 = wellKnownSymbol$7('iterator');
+var BUGGY_SAFARI_ITERATORS$1 = false;
+
+// `%IteratorPrototype%` object
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+var IteratorPrototype$4, PrototypeOfArrayIteratorPrototype, arrayIterator;
+
+/* eslint-disable es/no-array-prototype-keys -- safe */
+if ([].keys) {
+  arrayIterator = [].keys();
+  // Safari 8 has buggy iterators w/o `next`
+  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true;
+  else {
+    PrototypeOfArrayIteratorPrototype = getPrototypeOf$2(getPrototypeOf$2(arrayIterator));
+    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$4 = PrototypeOfArrayIteratorPrototype;
+  }
+}
+
+var NEW_ITERATOR_PROTOTYPE = !isObject$2(IteratorPrototype$4) || fails$3(function () {
+  var test = {};
+  // FF44- legacy iterators case
+  return IteratorPrototype$4[ITERATOR$6].call(test) !== test;
+});
+
+if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$4 = {};
+
+// `%IteratorPrototype%[@@iterator]()` method
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+if (!isCallable$2(IteratorPrototype$4[ITERATOR$6])) {
+  defineBuiltIn$3(IteratorPrototype$4, ITERATOR$6, function () {
+    return this;
+  });
+}
+
+var iteratorsCore = {
+  IteratorPrototype: IteratorPrototype$4,
+  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
+};
+
+var defineProperty$1 = objectDefineProperty.f;
+var hasOwn$2 = hasOwnProperty_1;
+var wellKnownSymbol$6 = wellKnownSymbol$c;
+
+var TO_STRING_TAG$2 = wellKnownSymbol$6('toStringTag');
+
+var setToStringTag$3 = function (target, TAG, STATIC) {
+  if (target && !STATIC) target = target.prototype;
+  if (target && !hasOwn$2(target, TO_STRING_TAG$2)) {
+    defineProperty$1(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
+  }
+};
+
+var IteratorPrototype$3 = iteratorsCore.IteratorPrototype;
+var create$1 = objectCreate;
+var createPropertyDescriptor$1 = createPropertyDescriptor$4;
+var setToStringTag$2 = setToStringTag$3;
+var Iterators$4 = iterators;
+
+var returnThis$1 = function () { return this; };
+
+var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
+  var TO_STRING_TAG = NAME + ' Iterator';
+  IteratorConstructor.prototype = create$1(IteratorPrototype$3, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) });
+  setToStringTag$2(IteratorConstructor, TO_STRING_TAG, false);
+  Iterators$4[TO_STRING_TAG] = returnThis$1;
+  return IteratorConstructor;
+};
+
+var uncurryThis$4 = functionUncurryThis;
+var aCallable$4 = aCallable$6;
+
+var functionUncurryThisAccessor = function (object, key, method) {
+  try {
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    return uncurryThis$4(aCallable$4(Object.getOwnPropertyDescriptor(object, key)[method]));
+  } catch (error) { /* empty */ }
+};
+
+var isObject$1 = isObject$8;
+
+var isPossiblePrototype$1 = function (argument) {
+  return isObject$1(argument) || argument === null;
+};
+
+var isPossiblePrototype = isPossiblePrototype$1;
+
+var $String = String;
+var $TypeError$4 = TypeError;
+
+var aPossiblePrototype$1 = function (argument) {
+  if (isPossiblePrototype(argument)) return argument;
+  throw new $TypeError$4("Can't set " + $String(argument) + ' as a prototype');
+};
+
+/* eslint-disable no-proto -- safe */
+var uncurryThisAccessor = functionUncurryThisAccessor;
+var isObject = isObject$8;
+var requireObjectCoercible$1 = requireObjectCoercible$4;
+var aPossiblePrototype = aPossiblePrototype$1;
+
+// `Object.setPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.setprototypeof
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+// eslint-disable-next-line es/no-object-setprototypeof -- safe
+var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+  var CORRECT_SETTER = false;
+  var test = {};
+  var setter;
+  try {
+    setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
+    setter(test, []);
+    CORRECT_SETTER = test instanceof Array;
+  } catch (error) { /* empty */ }
+  return function setPrototypeOf(O, proto) {
+    requireObjectCoercible$1(O);
+    aPossiblePrototype(proto);
+    if (!isObject(O)) return O;
+    if (CORRECT_SETTER) setter(O, proto);
+    else O.__proto__ = proto;
+    return O;
+  };
+}() : undefined);
+
+var $$4 = _export;
+var call$6 = functionCall;
+var FunctionName = functionName;
+var isCallable$1 = isCallable$g;
+var createIteratorConstructor = iteratorCreateConstructor;
+var getPrototypeOf$1 = objectGetPrototypeOf;
+var setPrototypeOf = objectSetPrototypeOf;
+var setToStringTag$1 = setToStringTag$3;
+var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
+var defineBuiltIn$2 = defineBuiltIn$5;
+var wellKnownSymbol$5 = wellKnownSymbol$c;
+var Iterators$3 = iterators;
+var IteratorsCore = iteratorsCore;
+
+var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER;
+var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
+var IteratorPrototype$2 = IteratorsCore.IteratorPrototype;
+var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+var ITERATOR$5 = wellKnownSymbol$5('iterator');
+var KEYS = 'keys';
+var VALUES = 'values';
+var ENTRIES = 'entries';
+
+var returnThis = function () { return this; };
+
+var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+  createIteratorConstructor(IteratorConstructor, NAME, next);
+
+  var getIterationMethod = function (KIND) {
+    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+    if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
+
+    switch (KIND) {
+      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
+      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
+      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
+    }
+
+    return function () { return new IteratorConstructor(this); };
+  };
+
+  var TO_STRING_TAG = NAME + ' Iterator';
+  var INCORRECT_VALUES_NAME = false;
+  var IterablePrototype = Iterable.prototype;
+  var nativeIterator = IterablePrototype[ITERATOR$5]
+    || IterablePrototype['@@iterator']
+    || DEFAULT && IterablePrototype[DEFAULT];
+  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+  var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
+  var CurrentIteratorPrototype, methods, KEY;
+
+  // fix native
+  if (anyNativeIterator) {
+    CurrentIteratorPrototype = getPrototypeOf$1(anyNativeIterator.call(new Iterable()));
+    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+      if (getPrototypeOf$1(CurrentIteratorPrototype) !== IteratorPrototype$2) {
+        if (setPrototypeOf) {
+          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2);
+        } else if (!isCallable$1(CurrentIteratorPrototype[ITERATOR$5])) {
+          defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$5, returnThis);
+        }
+      }
+      // Set @@toStringTag to native iterators
+      setToStringTag$1(CurrentIteratorPrototype, TO_STRING_TAG, true);
+    }
+  }
+
+  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
+  if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+    if (CONFIGURABLE_FUNCTION_NAME) {
+      createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
+    } else {
+      INCORRECT_VALUES_NAME = true;
+      defaultIterator = function values() { return call$6(nativeIterator, this); };
+    }
+  }
+
+  // export additional methods
+  if (DEFAULT) {
+    methods = {
+      values: getIterationMethod(VALUES),
+      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+      entries: getIterationMethod(ENTRIES)
+    };
+    if (FORCED) for (KEY in methods) {
+      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+        defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]);
+      }
+    } else $$4({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+  }
+
+  // define iterator
+  if (IterablePrototype[ITERATOR$5] !== defaultIterator) {
+    defineBuiltIn$2(IterablePrototype, ITERATOR$5, defaultIterator, { name: DEFAULT });
+  }
+  Iterators$3[NAME] = defaultIterator;
+
+  return methods;
+};
+
+// `CreateIterResultObject` abstract operation
+// https://tc39.es/ecma262/#sec-createiterresultobject
+var createIterResultObject$2 = function (value, done) {
+  return { value: value, done: done };
+};
+
+var toIndexedObject = toIndexedObject$5;
+var addToUnscopables = addToUnscopables$1;
+var Iterators$2 = iterators;
+var InternalStateModule$1 = internalState;
+var defineProperty = objectDefineProperty.f;
+var defineIterator = iteratorDefine;
+var createIterResultObject$1 = createIterResultObject$2;
+var DESCRIPTORS$2 = descriptors;
+
+var ARRAY_ITERATOR = 'Array Iterator';
+var setInternalState$1 = InternalStateModule$1.set;
+var getInternalState = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
+
+// `Array.prototype.entries` method
+// https://tc39.es/ecma262/#sec-array.prototype.entries
+// `Array.prototype.keys` method
+// https://tc39.es/ecma262/#sec-array.prototype.keys
+// `Array.prototype.values` method
+// https://tc39.es/ecma262/#sec-array.prototype.values
+// `Array.prototype[@@iterator]` method
+// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
+// `CreateArrayIterator` internal method
+// https://tc39.es/ecma262/#sec-createarrayiterator
+var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
+  setInternalState$1(this, {
+    type: ARRAY_ITERATOR,
+    target: toIndexedObject(iterated), // target
+    index: 0,                          // next index
+    kind: kind                         // kind
+  });
+// `%ArrayIteratorPrototype%.next` method
+// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
+}, function () {
+  var state = getInternalState(this);
+  var target = state.target;
+  var index = state.index++;
+  if (!target || index >= target.length) {
+    state.target = undefined;
+    return createIterResultObject$1(undefined, true);
+  }
+  switch (state.kind) {
+    case 'keys': return createIterResultObject$1(index, false);
+    case 'values': return createIterResultObject$1(target[index], false);
+  } return createIterResultObject$1([index, target[index]], false);
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values%
+// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
+// https://tc39.es/ecma262/#sec-createmappedargumentsobject
+var values = Iterators$2.Arguments = Iterators$2.Array;
+
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+
+// V8 ~ Chrome 45- bug
+if (DESCRIPTORS$2 && values.name !== 'values') try {
+  defineProperty(values, 'name', { value: 'values' });
+} catch (error) { /* empty */ }
+
+// `GetIteratorDirect(obj)` abstract operation
+// https://tc39.es/proposal-iterator-helpers/#sec-getiteratordirect
+var getIteratorDirect$2 = function (obj) {
+  return {
+    iterator: obj,
+    next: obj.next,
+    done: false
+  };
+};
+
+var defineBuiltIn$1 = defineBuiltIn$5;
+
+var defineBuiltIns$1 = function (target, src, options) {
+  for (var key in src) defineBuiltIn$1(target, key, src[key], options);
+  return target;
+};
+
+var call$5 = functionCall;
+var anObject$8 = anObject$d;
+var getMethod$2 = getMethod$4;
+
+var iteratorClose$3 = function (iterator, kind, value) {
+  var innerResult, innerError;
+  anObject$8(iterator);
+  try {
+    innerResult = getMethod$2(iterator, 'return');
+    if (!innerResult) {
+      if (kind === 'throw') throw value;
+      return value;
+    }
+    innerResult = call$5(innerResult, iterator);
+  } catch (error) {
+    innerError = true;
+    innerResult = error;
+  }
+  if (kind === 'throw') throw value;
+  if (innerError) throw innerResult;
+  anObject$8(innerResult);
+  return value;
+};
+
+var call$4 = functionCall;
+var create = objectCreate;
+var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
+var defineBuiltIns = defineBuiltIns$1;
+var wellKnownSymbol$4 = wellKnownSymbol$c;
+var InternalStateModule = internalState;
+var getMethod$1 = getMethod$4;
+var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
+var createIterResultObject = createIterResultObject$2;
+var iteratorClose$2 = iteratorClose$3;
+
+var TO_STRING_TAG$1 = wellKnownSymbol$4('toStringTag');
+var ITERATOR_HELPER = 'IteratorHelper';
+var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
+var setInternalState = InternalStateModule.set;
+
+var createIteratorProxyPrototype = function (IS_ITERATOR) {
+  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
+
+  return defineBuiltIns(create(IteratorPrototype$1), {
+    next: function next() {
+      var state = getInternalState(this);
+      // for simplification:
+      //   for `%WrapForValidIteratorPrototype%.next` our `nextHandler` returns `IterResultObject`
+      //   for `%IteratorHelperPrototype%.next` - just a value
+      if (IS_ITERATOR) return state.nextHandler();
+      try {
+        var result = state.done ? undefined : state.nextHandler();
+        return createIterResultObject(result, state.done);
+      } catch (error) {
+        state.done = true;
+        throw error;
+      }
+    },
+    'return': function () {
+      var state = getInternalState(this);
+      var iterator = state.iterator;
+      state.done = true;
+      if (IS_ITERATOR) {
+        var returnMethod = getMethod$1(iterator, 'return');
+        return returnMethod ? call$4(returnMethod, iterator) : createIterResultObject(undefined, true);
+      }
+      if (state.inner) try {
+        iteratorClose$2(state.inner.iterator, 'normal');
+      } catch (error) {
+        return iteratorClose$2(iterator, 'throw', error);
+      }
+      iteratorClose$2(iterator, 'normal');
+      return createIterResultObject(undefined, true);
+    }
+  });
+};
+
+var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
+var IteratorHelperPrototype = createIteratorProxyPrototype(false);
+
+createNonEnumerableProperty$1(IteratorHelperPrototype, TO_STRING_TAG$1, 'Iterator Helper');
+
+var iteratorCreateProxy = function (nextHandler, IS_ITERATOR) {
+  var IteratorProxy = function Iterator(record, state) {
+    if (state) {
+      state.iterator = record.iterator;
+      state.next = record.next;
+    } else state = record;
+    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+    state.nextHandler = nextHandler;
+    state.counter = 0;
+    state.done = false;
+    setInternalState(this, state);
+  };
+
+  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
+
+  return IteratorProxy;
+};
+
+var anObject$7 = anObject$d;
+var iteratorClose$1 = iteratorClose$3;
+
+// call something on iterator step with safe closing on error
+var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) {
+  try {
+    return ENTRIES ? fn(anObject$7(value)[0], value[1]) : fn(value);
+  } catch (error) {
+    iteratorClose$1(iterator, 'throw', error);
+  }
+};
+
+var call$3 = functionCall;
+var aCallable$3 = aCallable$6;
+var anObject$6 = anObject$d;
+var getIteratorDirect$1 = getIteratorDirect$2;
+var createIteratorProxy = iteratorCreateProxy;
+var callWithSafeIterationClosing = callWithSafeIterationClosing$1;
+
+var IteratorProxy = createIteratorProxy(function () {
+  var iterator = this.iterator;
+  var result = anObject$6(call$3(this.next, iterator));
+  var done = this.done = !!result.done;
+  if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);
+});
+
+// `Iterator.prototype.map` method
+// https://github.com/tc39/proposal-iterator-helpers
+var iteratorMap = function map(mapper) {
+  anObject$6(this);
+  aCallable$3(mapper);
+  return new IteratorProxy(getIteratorDirect$1(this), {
+    mapper: mapper
+  });
+};
+
+var $$3 = _export;
+var map = iteratorMap;
+var IS_PURE = isPure;
+
+// `Iterator.prototype.map` method
+// https://github.com/tc39/proposal-iterator-helpers
+$$3({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
+  map: map
+});
+
+// iterable DOM collections
+// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
+var domIterables = {
+  CSSRuleList: 0,
+  CSSStyleDeclaration: 0,
+  CSSValueList: 0,
+  ClientRectList: 0,
+  DOMRectList: 0,
+  DOMStringList: 0,
+  DOMTokenList: 1,
+  DataTransferItemList: 0,
+  FileList: 0,
+  HTMLAllCollection: 0,
+  HTMLCollection: 0,
+  HTMLFormElement: 0,
+  HTMLSelectElement: 0,
+  MediaList: 0,
+  MimeTypeArray: 0,
+  NamedNodeMap: 0,
+  NodeList: 1,
+  PaintRequestList: 0,
+  Plugin: 0,
+  PluginArray: 0,
+  SVGLengthList: 0,
+  SVGNumberList: 0,
+  SVGPathSegList: 0,
+  SVGPointList: 0,
+  SVGStringList: 0,
+  SVGTransformList: 0,
+  SourceBufferList: 0,
+  StyleSheetList: 0,
+  TextTrackCueList: 0,
+  TextTrackList: 0,
+  TouchList: 0
+};
+
+// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
+var documentCreateElement = documentCreateElement$2;
+
+var classList = documentCreateElement('span').classList;
+var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
+
+var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
+
+var global$3 = global$e;
+var DOMIterables = domIterables;
+var DOMTokenListPrototype = domTokenListPrototype;
+var ArrayIteratorMethods = es_array_iterator;
+var createNonEnumerableProperty = createNonEnumerableProperty$5;
+var setToStringTag = setToStringTag$3;
+var wellKnownSymbol$3 = wellKnownSymbol$c;
+
+var ITERATOR$4 = wellKnownSymbol$3('iterator');
+var ArrayValues = ArrayIteratorMethods.values;
+
+var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
+  if (CollectionPrototype) {
+    // some Chrome versions have non-configurable methods on DOMTokenList
+    if (CollectionPrototype[ITERATOR$4] !== ArrayValues) try {
+      createNonEnumerableProperty(CollectionPrototype, ITERATOR$4, ArrayValues);
+    } catch (error) {
+      CollectionPrototype[ITERATOR$4] = ArrayValues;
+    }
+    setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
+    if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
+      // some Chrome versions have non-configurable methods on DOMTokenList
+      if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
+        createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
+      } catch (error) {
+        CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
+      }
+    }
+  }
+};
+
+for (var COLLECTION_NAME in DOMIterables) {
+  handlePrototype(global$3[COLLECTION_NAME] && global$3[COLLECTION_NAME].prototype, COLLECTION_NAME);
+}
+
+handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
+
+var propTypes = {exports: {}};
+
+var reactIs = {exports: {}};
+
+var reactIs_production_min = {};
+
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactIs_production_min;
+
+function requireReactIs_production_min () {
+	if (hasRequiredReactIs_production_min) return reactIs_production_min;
+	hasRequiredReactIs_production_min = 1;
+var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
+	Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
+	function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=t;reactIs_production_min.Memo=r;reactIs_production_min.Portal=d;
+	reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min.isConcurrentMode=A;reactIs_production_min.isContextConsumer=function(a){return z(a)===k};reactIs_production_min.isContextProvider=function(a){return z(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return z(a)===n};reactIs_production_min.isFragment=function(a){return z(a)===e};reactIs_production_min.isLazy=function(a){return z(a)===t};
+	reactIs_production_min.isMemo=function(a){return z(a)===r};reactIs_production_min.isPortal=function(a){return z(a)===d};reactIs_production_min.isProfiler=function(a){return z(a)===g};reactIs_production_min.isStrictMode=function(a){return z(a)===f};reactIs_production_min.isSuspense=function(a){return z(a)===p};
+	reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min.typeOf=z;
+	return reactIs_production_min;
+}
+
+var reactIs_development = {};
+
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactIs_development;
+
+function requireReactIs_development () {
+	if (hasRequiredReactIs_development) return reactIs_development;
+	hasRequiredReactIs_development = 1;
+
+
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+	// nor polyfill, then a plain number is used for performance.
+	var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+	var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+	var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+	var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+	var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+	var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+	var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+	// (unstable) APIs that have been removed. Can we remove the symbols?
+
+	var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+	var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+	var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+	var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+	var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+	var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+	var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+	var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+	var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+	var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+	function isValidElementType(type) {
+	  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+	  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+	}
+
+	function typeOf(object) {
+	  if (typeof object === 'object' && object !== null) {
+	    var $$typeof = object.$$typeof;
+
+	    switch ($$typeof) {
+	      case REACT_ELEMENT_TYPE:
+	        var type = object.type;
+
+	        switch (type) {
+	          case REACT_ASYNC_MODE_TYPE:
+	          case REACT_CONCURRENT_MODE_TYPE:
+	          case REACT_FRAGMENT_TYPE:
+	          case REACT_PROFILER_TYPE:
+	          case REACT_STRICT_MODE_TYPE:
+	          case REACT_SUSPENSE_TYPE:
+	            return type;
+
+	          default:
+	            var $$typeofType = type && type.$$typeof;
+
+	            switch ($$typeofType) {
+	              case REACT_CONTEXT_TYPE:
+	              case REACT_FORWARD_REF_TYPE:
+	              case REACT_LAZY_TYPE:
+	              case REACT_MEMO_TYPE:
+	              case REACT_PROVIDER_TYPE:
+	                return $$typeofType;
+
+	              default:
+	                return $$typeof;
+	            }
+
+	        }
+
+	      case REACT_PORTAL_TYPE:
+	        return $$typeof;
+	    }
+	  }
+
+	  return undefined;
+	} // AsyncMode is deprecated along with isAsyncMode
+
+	var AsyncMode = REACT_ASYNC_MODE_TYPE;
+	var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+	var ContextConsumer = REACT_CONTEXT_TYPE;
+	var ContextProvider = REACT_PROVIDER_TYPE;
+	var Element = REACT_ELEMENT_TYPE;
+	var ForwardRef = REACT_FORWARD_REF_TYPE;
+	var Fragment = REACT_FRAGMENT_TYPE;
+	var Lazy = REACT_LAZY_TYPE;
+	var Memo = REACT_MEMO_TYPE;
+	var Portal = REACT_PORTAL_TYPE;
+	var Profiler = REACT_PROFILER_TYPE;
+	var StrictMode = REACT_STRICT_MODE_TYPE;
+	var Suspense = REACT_SUSPENSE_TYPE;
+	var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+	function isAsyncMode(object) {
+	  {
+	    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+	      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+	      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+	    }
+	  }
+
+	  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+	}
+	function isConcurrentMode(object) {
+	  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+	}
+	function isContextConsumer(object) {
+	  return typeOf(object) === REACT_CONTEXT_TYPE;
+	}
+	function isContextProvider(object) {
+	  return typeOf(object) === REACT_PROVIDER_TYPE;
+	}
+	function isElement(object) {
+	  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+	}
+	function isForwardRef(object) {
+	  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+	}
+	function isFragment(object) {
+	  return typeOf(object) === REACT_FRAGMENT_TYPE;
+	}
+	function isLazy(object) {
+	  return typeOf(object) === REACT_LAZY_TYPE;
+	}
+	function isMemo(object) {
+	  return typeOf(object) === REACT_MEMO_TYPE;
+	}
+	function isPortal(object) {
+	  return typeOf(object) === REACT_PORTAL_TYPE;
+	}
+	function isProfiler(object) {
+	  return typeOf(object) === REACT_PROFILER_TYPE;
+	}
+	function isStrictMode(object) {
+	  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+	}
+	function isSuspense(object) {
+	  return typeOf(object) === REACT_SUSPENSE_TYPE;
+	}
+
+	reactIs_development.AsyncMode = AsyncMode;
+	reactIs_development.ConcurrentMode = ConcurrentMode;
+	reactIs_development.ContextConsumer = ContextConsumer;
+	reactIs_development.ContextProvider = ContextProvider;
+	reactIs_development.Element = Element;
+	reactIs_development.ForwardRef = ForwardRef;
+	reactIs_development.Fragment = Fragment;
+	reactIs_development.Lazy = Lazy;
+	reactIs_development.Memo = Memo;
+	reactIs_development.Portal = Portal;
+	reactIs_development.Profiler = Profiler;
+	reactIs_development.StrictMode = StrictMode;
+	reactIs_development.Suspense = Suspense;
+	reactIs_development.isAsyncMode = isAsyncMode;
+	reactIs_development.isConcurrentMode = isConcurrentMode;
+	reactIs_development.isContextConsumer = isContextConsumer;
+	reactIs_development.isContextProvider = isContextProvider;
+	reactIs_development.isElement = isElement;
+	reactIs_development.isForwardRef = isForwardRef;
+	reactIs_development.isFragment = isFragment;
+	reactIs_development.isLazy = isLazy;
+	reactIs_development.isMemo = isMemo;
+	reactIs_development.isPortal = isPortal;
+	reactIs_development.isProfiler = isProfiler;
+	reactIs_development.isStrictMode = isStrictMode;
+	reactIs_development.isSuspense = isSuspense;
+	reactIs_development.isValidElementType = isValidElementType;
+	reactIs_development.typeOf = typeOf;
+	  })();
+	}
+	return reactIs_development;
+}
+
+var hasRequiredReactIs;
+
+function requireReactIs () {
+	if (hasRequiredReactIs) return reactIs.exports;
+	hasRequiredReactIs = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  reactIs.exports = requireReactIs_production_min();
+	} else {
+	  reactIs.exports = requireReactIs_development();
+	}
+	return reactIs.exports;
+}
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+var objectAssign;
+var hasRequiredObjectAssign;
+
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+	return objectAssign;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var ReactPropTypesSecret_1;
+var hasRequiredReactPropTypesSecret;
+
+function requireReactPropTypesSecret () {
+	if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
+	hasRequiredReactPropTypesSecret = 1;
+
+	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+	ReactPropTypesSecret_1 = ReactPropTypesSecret;
+	return ReactPropTypesSecret_1;
+}
+
+var has;
+var hasRequiredHas;
+
+function requireHas () {
+	if (hasRequiredHas) return has;
+	hasRequiredHas = 1;
+	has = Function.call.bind(Object.prototype.hasOwnProperty);
+	return has;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var checkPropTypes_1;
+var hasRequiredCheckPropTypes;
+
+function requireCheckPropTypes () {
+	if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+	hasRequiredCheckPropTypes = 1;
+
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactPropTypesSecret = requireReactPropTypesSecret();
+	  var loggedTypeFailures = {};
+	  var has = requireHas();
+
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) { /**/ }
+	  };
+	}
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?Function} getStack Returns the component stack.
+	 * @private
+	 */
+	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    for (var typeSpecName in typeSpecs) {
+	      if (has(typeSpecs, typeSpecName)) {
+	        var error;
+	        // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            var err = Error(
+	              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+	              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
+	              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
+	            );
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+	        } catch (ex) {
+	          error = ex;
+	        }
+	        if (error && !(error instanceof Error)) {
+	          printWarning(
+	            (componentName || 'React class') + ': type specification of ' +
+	            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+	            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+	            'You may have forgotten to pass an argument to the type checker ' +
+	            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+	            'shape all require an argument).'
+	          );
+	        }
+	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	          // Only monitor this failure once because there tends to be a lot of the
+	          // same error.
+	          loggedTypeFailures[error.message] = true;
+
+	          var stack = getStack ? getStack() : '';
+
+	          printWarning(
+	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+	          );
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Resets warning cache when testing.
+	 *
+	 * @private
+	 */
+	checkPropTypes.resetWarningCache = function() {
+	  if (process.env.NODE_ENV !== 'production') {
+	    loggedTypeFailures = {};
+	  }
+	};
+
+	checkPropTypes_1 = checkPropTypes;
+	return checkPropTypes_1;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var factoryWithTypeCheckers;
+var hasRequiredFactoryWithTypeCheckers;
+
+function requireFactoryWithTypeCheckers () {
+	if (hasRequiredFactoryWithTypeCheckers) return factoryWithTypeCheckers;
+	hasRequiredFactoryWithTypeCheckers = 1;
+
+	var ReactIs = requireReactIs();
+	var assign = requireObjectAssign();
+
+	var ReactPropTypesSecret = requireReactPropTypesSecret();
+	var has = requireHas();
+	var checkPropTypes = requireCheckPropTypes();
+
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) {}
+	  };
+	}
+
+	function emptyFunctionThatReturnsNull() {
+	  return null;
+	}
+
+	factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
+	  /* global Symbol */
+	  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+	  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+	  /**
+	   * Returns the iterator method function contained on the iterable object.
+	   *
+	   * Be sure to invoke the function with the iterable as context:
+	   *
+	   *     var iteratorFn = getIteratorFn(myIterable);
+	   *     if (iteratorFn) {
+	   *       var iterator = iteratorFn.call(myIterable);
+	   *       ...
+	   *     }
+	   *
+	   * @param {?object} maybeIterable
+	   * @return {?function}
+	   */
+	  function getIteratorFn(maybeIterable) {
+	    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+	    if (typeof iteratorFn === 'function') {
+	      return iteratorFn;
+	    }
+	  }
+
+	  /**
+	   * Collection of methods that allow declaration and validation of props that are
+	   * supplied to React components. Example usage:
+	   *
+	   *   var Props = require('ReactPropTypes');
+	   *   var MyArticle = React.createClass({
+	   *     propTypes: {
+	   *       // An optional string prop named "description".
+	   *       description: Props.string,
+	   *
+	   *       // A required enum prop named "category".
+	   *       category: Props.oneOf(['News','Photos']).isRequired,
+	   *
+	   *       // A prop named "dialog" that requires an instance of Dialog.
+	   *       dialog: Props.instanceOf(Dialog).isRequired
+	   *     },
+	   *     render: function() { ... }
+	   *   });
+	   *
+	   * A more formal specification of how these methods are used:
+	   *
+	   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+	   *   decl := ReactPropTypes.{type}(.isRequired)?
+	   *
+	   * Each and every declaration produces a function with the same signature. This
+	   * allows the creation of custom validation functions. For example:
+	   *
+	   *  var MyLink = React.createClass({
+	   *    propTypes: {
+	   *      // An optional string or URI prop named "href".
+	   *      href: function(props, propName, componentName) {
+	   *        var propValue = props[propName];
+	   *        if (propValue != null && typeof propValue !== 'string' &&
+	   *            !(propValue instanceof URI)) {
+	   *          return new Error(
+	   *            'Expected a string or an URI for ' + propName + ' in ' +
+	   *            componentName
+	   *          );
+	   *        }
+	   *      }
+	   *    },
+	   *    render: function() {...}
+	   *  });
+	   *
+	   * @internal
+	   */
+
+	  var ANONYMOUS = '<<anonymous>>';
+
+	  // Important!
+	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+	  var ReactPropTypes = {
+	    array: createPrimitiveTypeChecker('array'),
+	    bigint: createPrimitiveTypeChecker('bigint'),
+	    bool: createPrimitiveTypeChecker('boolean'),
+	    func: createPrimitiveTypeChecker('function'),
+	    number: createPrimitiveTypeChecker('number'),
+	    object: createPrimitiveTypeChecker('object'),
+	    string: createPrimitiveTypeChecker('string'),
+	    symbol: createPrimitiveTypeChecker('symbol'),
+
+	    any: createAnyTypeChecker(),
+	    arrayOf: createArrayOfTypeChecker,
+	    element: createElementTypeChecker(),
+	    elementType: createElementTypeTypeChecker(),
+	    instanceOf: createInstanceTypeChecker,
+	    node: createNodeChecker(),
+	    objectOf: createObjectOfTypeChecker,
+	    oneOf: createEnumTypeChecker,
+	    oneOfType: createUnionTypeChecker,
+	    shape: createShapeTypeChecker,
+	    exact: createStrictShapeTypeChecker,
+	  };
+
+	  /**
+	   * inlined Object.is polyfill to avoid requiring consumers ship their own
+	   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	   */
+	  /*eslint-disable no-self-compare*/
+	  function is(x, y) {
+	    // SameValue algorithm
+	    if (x === y) {
+	      // Steps 1-5, 7-10
+	      // Steps 6.b-6.e: +0 != -0
+	      return x !== 0 || 1 / x === 1 / y;
+	    } else {
+	      // Step 6.a: NaN == NaN
+	      return x !== x && y !== y;
+	    }
+	  }
+	  /*eslint-enable no-self-compare*/
+
+	  /**
+	   * We use an Error-like object for backward compatibility as people may call
+	   * PropTypes directly and inspect their output. However, we don't use real
+	   * Errors anymore. We don't inspect their stack anyway, and creating them
+	   * is prohibitively expensive if they are created too often, such as what
+	   * happens in oneOfType() for any type before the one that matched.
+	   */
+	  function PropTypeError(message, data) {
+	    this.message = message;
+	    this.data = data && typeof data === 'object' ? data: {};
+	    this.stack = '';
+	  }
+	  // Make `instanceof Error` still work for returned errors.
+	  PropTypeError.prototype = Error.prototype;
+
+	  function createChainableTypeChecker(validate) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var manualPropTypeCallCache = {};
+	      var manualPropTypeWarningCount = 0;
+	    }
+	    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+	      componentName = componentName || ANONYMOUS;
+	      propFullName = propFullName || propName;
+
+	      if (secret !== ReactPropTypesSecret) {
+	        if (throwOnDirectAccess) {
+	          // New behavior only for users of `prop-types` package
+	          var err = new Error(
+	            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+	            'Use `PropTypes.checkPropTypes()` to call them. ' +
+	            'Read more at http://fb.me/use-check-prop-types'
+	          );
+	          err.name = 'Invariant Violation';
+	          throw err;
+	        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+	          // Old behavior for people using React.PropTypes
+	          var cacheKey = componentName + ':' + propName;
+	          if (
+	            !manualPropTypeCallCache[cacheKey] &&
+	            // Avoid spamming the console because they are often not actionable except for lib authors
+	            manualPropTypeWarningCount < 3
+	          ) {
+	            printWarning(
+	              'You are manually calling a React.PropTypes validation ' +
+	              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
+	              'and will throw in the standalone `prop-types` package. ' +
+	              'You may be seeing this warning due to a third-party PropTypes ' +
+	              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
+	            );
+	            manualPropTypeCallCache[cacheKey] = true;
+	            manualPropTypeWarningCount++;
+	          }
+	        }
+	      }
+	      if (props[propName] == null) {
+	        if (isRequired) {
+	          if (props[propName] === null) {
+	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+	          }
+	          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+	        }
+	        return null;
+	      } else {
+	        return validate(props, propName, componentName, location, propFullName);
+	      }
+	    }
+
+	    var chainedCheckType = checkType.bind(null, false);
+	    chainedCheckType.isRequired = checkType.bind(null, true);
+
+	    return chainedCheckType;
+	  }
+
+	  function createPrimitiveTypeChecker(expectedType) {
+	    function validate(props, propName, componentName, location, propFullName, secret) {
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== expectedType) {
+	        // `propValue` being instance of, say, date/regexp, pass the 'object'
+	        // check, but we can offer a more precise error message here rather than
+	        // 'of type `object`'.
+	        var preciseType = getPreciseType(propValue);
+
+	        return new PropTypeError(
+	          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
+	          {expectedType: expectedType}
+	        );
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createAnyTypeChecker() {
+	    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+	  }
+
+	  function createArrayOfTypeChecker(typeChecker) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (typeof typeChecker !== 'function') {
+	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+	      }
+	      var propValue = props[propName];
+	      if (!Array.isArray(propValue)) {
+	        var propType = getPropType(propValue);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+	      }
+	      for (var i = 0; i < propValue.length; i++) {
+	        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+	        if (error instanceof Error) {
+	          return error;
+	        }
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createElementTypeChecker() {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      if (!isValidElement(propValue)) {
+	        var propType = getPropType(propValue);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createElementTypeTypeChecker() {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      if (!ReactIs.isValidElementType(propValue)) {
+	        var propType = getPropType(propValue);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createInstanceTypeChecker(expectedClass) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (!(props[propName] instanceof expectedClass)) {
+	        var expectedClassName = expectedClass.name || ANONYMOUS;
+	        var actualClassName = getClassName(props[propName]);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createEnumTypeChecker(expectedValues) {
+	    if (!Array.isArray(expectedValues)) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        if (arguments.length > 1) {
+	          printWarning(
+	            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
+	            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
+	          );
+	        } else {
+	          printWarning('Invalid argument supplied to oneOf, expected an array.');
+	        }
+	      }
+	      return emptyFunctionThatReturnsNull;
+	    }
+
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      for (var i = 0; i < expectedValues.length; i++) {
+	        if (is(propValue, expectedValues[i])) {
+	          return null;
+	        }
+	      }
+
+	      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+	        var type = getPreciseType(value);
+	        if (type === 'symbol') {
+	          return String(value);
+	        }
+	        return value;
+	      });
+	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createObjectOfTypeChecker(typeChecker) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (typeof typeChecker !== 'function') {
+	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+	      }
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== 'object') {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+	      }
+	      for (var key in propValue) {
+	        if (has(propValue, key)) {
+	          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	          if (error instanceof Error) {
+	            return error;
+	          }
+	        }
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createUnionTypeChecker(arrayOfTypeCheckers) {
+	    if (!Array.isArray(arrayOfTypeCheckers)) {
+	      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+	      return emptyFunctionThatReturnsNull;
+	    }
+
+	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+	      var checker = arrayOfTypeCheckers[i];
+	      if (typeof checker !== 'function') {
+	        printWarning(
+	          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
+	          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
+	        );
+	        return emptyFunctionThatReturnsNull;
+	      }
+	    }
+
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var expectedTypes = [];
+	      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+	        var checker = arrayOfTypeCheckers[i];
+	        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+	        if (checkerResult == null) {
+	          return null;
+	        }
+	        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
+	          expectedTypes.push(checkerResult.data.expectedType);
+	        }
+	      }
+	      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
+	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createNodeChecker() {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (!isNode(props[propName])) {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function invalidValidatorError(componentName, location, propFullName, key, type) {
+	    return new PropTypeError(
+	      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
+	      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
+	    );
+	  }
+
+	  function createShapeTypeChecker(shapeTypes) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== 'object') {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+	      }
+	      for (var key in shapeTypes) {
+	        var checker = shapeTypes[key];
+	        if (typeof checker !== 'function') {
+	          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+	        }
+	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	        if (error) {
+	          return error;
+	        }
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createStrictShapeTypeChecker(shapeTypes) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== 'object') {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+	      }
+	      // We need to check all keys in case some are required but missing from props.
+	      var allKeys = assign({}, props[propName], shapeTypes);
+	      for (var key in allKeys) {
+	        var checker = shapeTypes[key];
+	        if (has(shapeTypes, key) && typeof checker !== 'function') {
+	          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+	        }
+	        if (!checker) {
+	          return new PropTypeError(
+	            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
+	            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
+	            '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')
+	          );
+	        }
+	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	        if (error) {
+	          return error;
+	        }
+	      }
+	      return null;
+	    }
+
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function isNode(propValue) {
+	    switch (typeof propValue) {
+	      case 'number':
+	      case 'string':
+	      case 'undefined':
+	        return true;
+	      case 'boolean':
+	        return !propValue;
+	      case 'object':
+	        if (Array.isArray(propValue)) {
+	          return propValue.every(isNode);
+	        }
+	        if (propValue === null || isValidElement(propValue)) {
+	          return true;
+	        }
+
+	        var iteratorFn = getIteratorFn(propValue);
+	        if (iteratorFn) {
+	          var iterator = iteratorFn.call(propValue);
+	          var step;
+	          if (iteratorFn !== propValue.entries) {
+	            while (!(step = iterator.next()).done) {
+	              if (!isNode(step.value)) {
+	                return false;
+	              }
+	            }
+	          } else {
+	            // Iterator will provide entry [k,v] tuples rather than values.
+	            while (!(step = iterator.next()).done) {
+	              var entry = step.value;
+	              if (entry) {
+	                if (!isNode(entry[1])) {
+	                  return false;
+	                }
+	              }
+	            }
+	          }
+	        } else {
+	          return false;
+	        }
+
+	        return true;
+	      default:
+	        return false;
+	    }
+	  }
+
+	  function isSymbol(propType, propValue) {
+	    // Native Symbol.
+	    if (propType === 'symbol') {
+	      return true;
+	    }
+
+	    // falsy value can't be a Symbol
+	    if (!propValue) {
+	      return false;
+	    }
+
+	    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+	    if (propValue['@@toStringTag'] === 'Symbol') {
+	      return true;
+	    }
+
+	    // Fallback for non-spec compliant Symbols which are polyfilled.
+	    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  // Equivalent of `typeof` but with special handling for array and regexp.
+	  function getPropType(propValue) {
+	    var propType = typeof propValue;
+	    if (Array.isArray(propValue)) {
+	      return 'array';
+	    }
+	    if (propValue instanceof RegExp) {
+	      // Old webkits (at least until Android 4.0) return 'function' rather than
+	      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+	      // passes PropTypes.object.
+	      return 'object';
+	    }
+	    if (isSymbol(propType, propValue)) {
+	      return 'symbol';
+	    }
+	    return propType;
+	  }
+
+	  // This handles more types than `getPropType`. Only used for error messages.
+	  // See `createPrimitiveTypeChecker`.
+	  function getPreciseType(propValue) {
+	    if (typeof propValue === 'undefined' || propValue === null) {
+	      return '' + propValue;
+	    }
+	    var propType = getPropType(propValue);
+	    if (propType === 'object') {
+	      if (propValue instanceof Date) {
+	        return 'date';
+	      } else if (propValue instanceof RegExp) {
+	        return 'regexp';
+	      }
+	    }
+	    return propType;
+	  }
+
+	  // Returns a string that is postfixed to a warning about an invalid type.
+	  // For example, "undefined" or "of type array"
+	  function getPostfixForTypeWarning(value) {
+	    var type = getPreciseType(value);
+	    switch (type) {
+	      case 'array':
+	      case 'object':
+	        return 'an ' + type;
+	      case 'boolean':
+	      case 'date':
+	      case 'regexp':
+	        return 'a ' + type;
+	      default:
+	        return type;
+	    }
+	  }
+
+	  // Returns class name of the object, if any.
+	  function getClassName(propValue) {
+	    if (!propValue.constructor || !propValue.constructor.name) {
+	      return ANONYMOUS;
+	    }
+	    return propValue.constructor.name;
+	  }
+
+	  ReactPropTypes.checkPropTypes = checkPropTypes;
+	  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+	  ReactPropTypes.PropTypes = ReactPropTypes;
+
+	  return ReactPropTypes;
+	};
+	return factoryWithTypeCheckers;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var factoryWithThrowingShims;
+var hasRequiredFactoryWithThrowingShims;
+
+function requireFactoryWithThrowingShims () {
+	if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+	hasRequiredFactoryWithThrowingShims = 1;
+
+	var ReactPropTypesSecret = requireReactPropTypesSecret();
+
+	function emptyFunction() {}
+	function emptyFunctionWithReset() {}
+	emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+	factoryWithThrowingShims = function() {
+	  function shim(props, propName, componentName, location, propFullName, secret) {
+	    if (secret === ReactPropTypesSecret) {
+	      // It is still safe when called from React.
+	      return;
+	    }
+	    var err = new Error(
+	      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+	      'Use PropTypes.checkPropTypes() to call them. ' +
+	      'Read more at http://fb.me/use-check-prop-types'
+	    );
+	    err.name = 'Invariant Violation';
+	    throw err;
+	  }	  shim.isRequired = shim;
+	  function getShim() {
+	    return shim;
+	  }	  // Important!
+	  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+	  var ReactPropTypes = {
+	    array: shim,
+	    bigint: shim,
+	    bool: shim,
+	    func: shim,
+	    number: shim,
+	    object: shim,
+	    string: shim,
+	    symbol: shim,
+
+	    any: shim,
+	    arrayOf: getShim,
+	    element: shim,
+	    elementType: shim,
+	    instanceOf: getShim,
+	    node: shim,
+	    objectOf: getShim,
+	    oneOf: getShim,
+	    oneOfType: getShim,
+	    shape: getShim,
+	    exact: getShim,
+
+	    checkPropTypes: emptyFunctionWithReset,
+	    resetWarningCache: emptyFunction
+	  };
+
+	  ReactPropTypes.PropTypes = ReactPropTypes;
+
+	  return ReactPropTypes;
+	};
+	return factoryWithThrowingShims;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== 'production') {
+  var ReactIs = requireReactIs();
+
+  // By explicitly using `prop-types` you are opting into new development behavior.
+  // http://fb.me/prop-types-in-prod
+  var throwOnDirectAccess = true;
+  propTypes.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+} else {
+  // By explicitly using `prop-types` you are opting into new production behavior.
+  // http://fb.me/prop-types-in-prod
+  propTypes.exports = requireFactoryWithThrowingShims()();
+}
+
+var propTypesExports = propTypes.exports;
+var PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var createReactComponent = (iconName, iconNamePascal, iconNode) => {
+  const Component = forwardRef(
+    (_a, ref) => {
+      var _b = _a, { color = "currentColor", size = 24, stroke = 2, children } = _b, rest = __objRest(_b, ["color", "size", "stroke", "children"]);
+      return createElement$1(
+        "svg",
+        __spreadValues(__spreadProps(__spreadValues({
+          ref
+        }, defaultAttributes), {
+          width: size,
+          height: size,
+          stroke: color,
+          strokeWidth: stroke,
+          className: `tabler-icon tabler-icon-${iconName}`
+        }), rest),
+        [...iconNode.map(([tag, attrs]) => createElement$1(tag, attrs)), ...children || []]
+      );
+    }
+  );
+  Component.propTypes = {
+    color: PropTypes.string,
+    size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    stroke: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
+  };
+  Component.displayName = `${iconNamePascal}`;
+  return Component;
+};
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconBrandWindows = createReactComponent("brand-windows", "IconBrandWindows", [
+  [
+    "path",
+    {
+      d: "M17.8 20l-12 -1.5c-1 -.1 -1.8 -.9 -1.8 -1.9v-9.2c0 -1 .8 -1.8 1.8 -1.9l12 -1.5c1.2 -.1 2.2 .8 2.2 1.9v12.1c0 1.2 -1.1 2.1 -2.2 1.9z",
+      key: "svg-0"
+    }
+  ],
+  ["path", { d: "M12 5l0 14", key: "svg-1" }],
+  ["path", { d: "M4 12l16 0", key: "svg-2" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconBuildingBridge = createReactComponent("building-bridge", "IconBuildingBridge", [
+  ["path", { d: "M6 5l0 14", key: "svg-0" }],
+  ["path", { d: "M18 5l0 14", key: "svg-1" }],
+  ["path", { d: "M2 15l20 0", key: "svg-2" }],
+  [
+    "path",
+    {
+      d: "M3 8a7.5 7.5 0 0 0 3 -2a6.5 6.5 0 0 0 12 0a7.5 7.5 0 0 0 3 2",
+      key: "svg-3"
+    }
+  ],
+  ["path", { d: "M12 10l0 5", key: "svg-4" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconCircle = createReactComponent("circle", "IconCircle", [
+  ["path", { d: "M12 12m-9 0a9 9 0 1 0 18 0a9 9 0 1 0 -18 0", key: "svg-0" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconDotsVertical = createReactComponent("dots-vertical", "IconDotsVertical", [
+  ["path", { d: "M12 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0", key: "svg-0" }],
+  ["path", { d: "M12 19m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0", key: "svg-1" }],
+  ["path", { d: "M12 5m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0", key: "svg-2" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconExternalLink = createReactComponent("external-link", "IconExternalLink", [
+  [
+    "path",
+    {
+      d: "M12 6h-6a2 2 0 0 0 -2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2 -2v-6",
+      key: "svg-0"
+    }
+  ],
+  ["path", { d: "M11 13l9 -9", key: "svg-1" }],
+  ["path", { d: "M15 4h5v5", key: "svg-2" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconLine = createReactComponent("line", "IconLine", [
+  ["path", { d: "M6 18m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-0" }],
+  ["path", { d: "M18 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-1" }],
+  ["path", { d: "M7.5 16.5l9 -9", key: "svg-2" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconManualGearbox = createReactComponent("manual-gearbox", "IconManualGearbox", [
+  ["path", { d: "M5 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-0" }],
+  ["path", { d: "M12 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-1" }],
+  ["path", { d: "M19 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-2" }],
+  ["path", { d: "M5 18m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-3" }],
+  ["path", { d: "M12 18m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-4" }],
+  ["path", { d: "M5 8l0 8", key: "svg-5" }],
+  ["path", { d: "M12 8l0 8", key: "svg-6" }],
+  ["path", { d: "M19 8v2a2 2 0 0 1 -2 2h-12", key: "svg-7" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconPlus = createReactComponent("plus", "IconPlus", [
+  ["path", { d: "M12 5l0 14", key: "svg-0" }],
+  ["path", { d: "M5 12l14 0", key: "svg-1" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconPrinter = createReactComponent("printer", "IconPrinter", [
+  [
+    "path",
+    {
+      d: "M17 17h2a2 2 0 0 0 2 -2v-4a2 2 0 0 0 -2 -2h-14a2 2 0 0 0 -2 2v4a2 2 0 0 0 2 2h2",
+      key: "svg-0"
+    }
+  ],
+  ["path", { d: "M17 9v-4a2 2 0 0 0 -2 -2h-6a2 2 0 0 0 -2 2v4", key: "svg-1" }],
+  [
+    "path",
+    {
+      d: "M7 13m0 2a2 2 0 0 1 2 -2h6a2 2 0 0 1 2 2v4a2 2 0 0 1 -2 2h-6a2 2 0 0 1 -2 -2z",
+      key: "svg-2"
+    }
+  ]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconRefresh = createReactComponent("refresh", "IconRefresh", [
+  ["path", { d: "M20 11a8.1 8.1 0 0 0 -15.5 -2m-.5 -4v4h4", key: "svg-0" }],
+  ["path", { d: "M4 13a8.1 8.1 0 0 0 15.5 2m.5 4v-4h-4", key: "svg-1" }]
+]);
+
+/**
+ * @tabler/icons-react v2.47.0 - MIT
+ */
+
+
+var IconTrash = createReactComponent("trash", "IconTrash", [
+  ["path", { d: "M4 7l16 0", key: "svg-0" }],
+  ["path", { d: "M10 11l0 6", key: "svg-1" }],
+  ["path", { d: "M14 11l0 6", key: "svg-2" }],
+  [
+    "path",
+    { d: "M5 7l1 12a2 2 0 0 0 2 2h8a2 2 0 0 0 2 -2l1 -12", key: "svg-3" }
+  ],
+  ["path", { d: "M9 7v-3a1 1 0 0 1 1 -1h4a1 1 0 0 1 1 1v3", key: "svg-4" }]
+]);
+
+function AddPrintServer(props) {
+  const [type, setType] = useState(null);
+  const [printSystem, setPrintSystem] = useState(null);
+  const [name, setName] = useState('');
+  const [description, setDescription] = useState('');
+  const [host, setHost] = useState('');
+  const [port, setPort] = useState(631);
+  useEffect(() => {
+    setPrintSystem(null);
+  }, [type]);
+  const isValid = () => {
+    if (type === null) return false;
+    if (name === null || name === '') return false;
+    if (description === null || description === '') return false;
+    if (printSystem === null) return false;
+    if (printSystem === 'ipp' && (host === null || host === '')) return false;
+    if (printSystem === 'ipp' && (port === null || port === '')) return false;
+    return true;
+  };
+  const submit = () => {
+    const command = {
+      type: type === 'direct' ? PrintServerType.Direct : PrintServerType.Remote,
+      name: name,
+      description: description,
+      managedType: printSystem === 'ipp' ? PrintServerManagedType.Ipp : PrintServerManagedType.Windows,
+      ipAddress: host !== null ? host : "",
+      port: port !== "" ? port : 0
+    };
+    FluxoClientSys.Instance.printing.CreatePrintServer(command).then(a => {
+      showNotification({
+        title: 'Print server creato',
+        message: 'Il print server è stato creato con successo',
+        color: 'green'
+      });
+      props.onSaved();
+    }).catch(e => {
+      showNotification({
+        title: 'Errore',
+        message: 'Si è verificato un errore durante la creazione del print server',
+        color: 'red'
+      });
+    });
+  };
+  return jsxs(Stack, {
+    gap: 8,
+    children: [jsx(Text, {
+      size: 'md',
+      children: "Informazioni"
+    }), jsx(TextInput, {
+      label: 'Nome',
+      onChange: v => setName(v.target.value)
+    }), jsx(TextInput, {
+      label: 'Descrizione',
+      onChange: v => setDescription(v.target.value)
+    }), jsx(Text, {
+      size: 'md',
+      children: "Configurazione"
+    }), jsx(Select, {
+      label: 'Tipo',
+      value: type,
+      data: [{
+        label: 'Diretto',
+        value: 'direct'
+      }, {
+        label: 'Remoto',
+        value: 'remote'
+      }],
+      onChange: v => setType(v)
+    }), jsx(Select, {
+      label: 'Sistema di stampa',
+      disabled: type === null,
+      value: printSystem,
+      data: [{
+        label: 'IPP / CUPS',
+        value: 'ipp'
+      }, {
+        label: 'Windows',
+        value: 'windows',
+        disabled: type === 'remote'
+      }],
+      onChange: v => setPrintSystem(v)
+    }), printSystem === 'ipp' && jsxs(Fragment, {
+      children: [jsx(TextInput, {
+        label: 'IPP - Host',
+        placeholder: 'Es: localhost',
+        onChange: v => setHost(v.target.value)
+      }), jsx(NumberInput, {
+        label: 'IPP - Porta',
+        placeholder: 'Es: 631',
+        min: 1,
+        max: 65534,
+        onChange: v => setPort(+v)
+      })]
+    }), jsxs(Group, {
+      align: 'end',
+      justify: 'right',
+      children: [jsx(Button, {
+        onClick: () => props.onCanceled(),
+        variant: 'subtle',
+        children: "Annulla"
+      }), jsx(Button, {
+        onClick: submit,
+        disabled: !isValid(),
+        children: "Salva"
+      })]
+    })]
+  });
+}
+
+// a string of all valid unicode whitespaces
+var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
+  '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
+
+var uncurryThis$3 = functionUncurryThis;
+var requireObjectCoercible = requireObjectCoercible$4;
+var toString$1 = toString$3;
+var whitespaces$1 = whitespaces$2;
+
+var replace = uncurryThis$3(''.replace);
+var ltrim = RegExp('^[' + whitespaces$1 + ']+');
+var rtrim = RegExp('(^|[^' + whitespaces$1 + '])[' + whitespaces$1 + ']+$');
+
+// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
+var createMethod = function (TYPE) {
+  return function ($this) {
+    var string = toString$1(requireObjectCoercible($this));
+    if (TYPE & 1) string = replace(string, ltrim, '');
+    if (TYPE & 2) string = replace(string, rtrim, '$1');
+    return string;
+  };
+};
+
+var stringTrim = {
+  // `String.prototype.{ trimLeft, trimStart }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
+  start: createMethod(1),
+  // `String.prototype.{ trimRight, trimEnd }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimend
+  end: createMethod(2),
+  // `String.prototype.trim` method
+  // https://tc39.es/ecma262/#sec-string.prototype.trim
+  trim: createMethod(3)
+};
+
+var global$2 = global$e;
+var fails$2 = fails$d;
+var uncurryThis$2 = functionUncurryThis;
+var toString = toString$3;
+var trim = stringTrim.trim;
+var whitespaces = whitespaces$2;
+
+var $parseInt$1 = global$2.parseInt;
+var Symbol$1 = global$2.Symbol;
+var ITERATOR$3 = Symbol$1 && Symbol$1.iterator;
+var hex = /^[+-]?0x/i;
+var exec = uncurryThis$2(hex.exec);
+var FORCED$1 = $parseInt$1(whitespaces + '08') !== 8 || $parseInt$1(whitespaces + '0x16') !== 22
+  // MS Edge 18- broken with boxed symbols
+  || (ITERATOR$3 && !fails$2(function () { $parseInt$1(Object(ITERATOR$3)); }));
+
+// `parseInt` method
+// https://tc39.es/ecma262/#sec-parseint-string-radix
+var numberParseInt = FORCED$1 ? function parseInt(string, radix) {
+  var S = trim(toString(string));
+  return $parseInt$1(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));
+} : $parseInt$1;
+
+var $$2 = _export;
+var $parseInt = numberParseInt;
+
+// `parseInt` method
+// https://tc39.es/ecma262/#sec-parseint-string-radix
+$$2({ global: true, forced: parseInt !== $parseInt }, {
+  parseInt: $parseInt
+});
+
+var anObject$5 = anObject$d;
+
+// `RegExp.prototype.flags` getter implementation
+// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
+var regexpFlags = function () {
+  var that = anObject$5(this);
+  var result = '';
+  if (that.hasIndices) result += 'd';
+  if (that.global) result += 'g';
+  if (that.ignoreCase) result += 'i';
+  if (that.multiline) result += 'm';
+  if (that.dotAll) result += 's';
+  if (that.unicode) result += 'u';
+  if (that.unicodeSets) result += 'v';
+  if (that.sticky) result += 'y';
+  return result;
+};
+
+var call$2 = functionCall;
+var hasOwn$1 = hasOwnProperty_1;
+var isPrototypeOf$2 = objectIsPrototypeOf;
+var regExpFlags = regexpFlags;
+
+var RegExpPrototype$1 = RegExp.prototype;
+
+var regexpGetFlags = function (R) {
+  var flags = R.flags;
+  return flags === undefined && !('flags' in RegExpPrototype$1) && !hasOwn$1(R, 'flags') && isPrototypeOf$2(RegExpPrototype$1, R)
+    ? call$2(regExpFlags, R) : flags;
+};
+
+var PROPER_FUNCTION_NAME = functionName.PROPER;
+var defineBuiltIn = defineBuiltIn$5;
+var anObject$4 = anObject$d;
+var $toString = toString$3;
+var fails$1 = fails$d;
+var getRegExpFlags = regexpGetFlags;
+
+var TO_STRING = 'toString';
+var RegExpPrototype = RegExp.prototype;
+var nativeToString = RegExpPrototype[TO_STRING];
+
+var NOT_GENERIC = fails$1(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
+// FF44- RegExp#toString has a wrong name
+var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
+
+// `RegExp.prototype.toString` method
+// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
+if (NOT_GENERIC || INCORRECT_NAME) {
+  defineBuiltIn(RegExpPrototype, TO_STRING, function toString() {
+    var R = anObject$4(this);
+    var pattern = $toString(R.source);
+    var flags = $toString(getRegExpFlags(R));
+    return '/' + pattern + '/' + flags;
+  }, { unsafe: true });
+}
+
+function AddPrinter(props) {
+  const [printers, setPrinters] = useState([]);
+  const [printerType, setPrinterType] = useState('managed');
+  const [name, setName] = useState('');
+  const [description, setDescription] = useState('');
+  const [mappedPrinter, setMappedPrinter] = useState('');
+  const [manufacturer, setManufacturer] = useState('');
+  const [ipAddress, setIpAddress] = useState('');
+  const [port, setPort] = useState(631);
+  useEffect(() => {
+    FluxoClientSys.Instance.printing.GetPrintServerPrinters(props.printServerId).then(res => {
+      setPrinters(res);
+    }).catch(e => {
+      showNotification({
+        title: 'Errore',
+        message: `Si è verificato un errore durante il caricamento delle stampanti: ${e.message}`,
+        color: 'red'
+      });
+    });
+  }, []);
+  const isValid = useCallback(() => {
+    if (printerType === null) return false;
+    if (name === null || name === '') return false;
+    if (description === null || description === '') return false;
+    if (printerType === 'managed' && (mappedPrinter === null || mappedPrinter === '')) return false;
+    if (printerType === 'unmanaged' && (manufacturer === null || manufacturer === '')) return false;
+    if (printerType === 'unmanaged' && (ipAddress === null || ipAddress === '')) return false;
+    if (printerType === 'unmanaged' && (port === null || port === '')) return false;
+    return true;
+  }, [printerType, name, description, mappedPrinter, manufacturer, ipAddress, port]);
+  const submit = () => {
+    const command = {
+      name: name,
+      description: description,
+      mappedPrinterName: mappedPrinter !== null ? mappedPrinter : "",
+      ipAddress: ipAddress !== null ? ipAddress : "",
+      port: port !== "" ? port : 0,
+      type: printerType === 'managed' ? PrinterType.Managed : PrinterType.Unmanaged,
+      manufacturer: manufacturer !== null ? parseInt(manufacturer) : 0
+    };
+    FluxoClientSys.Instance.printing.AddPrinter(props.printServerId, command).then(a => {
+      showNotification({
+        title: 'Stampante creata',
+        message: 'La stampante è stata creata con successo',
+        color: 'green'
+      });
+      props.onSaved();
+    }).catch(e => {
+      showNotification({
+        title: 'Errore',
+        message: e.message,
+        color: 'red'
+      });
+    });
+  };
+  return jsxs(Stack, {
+    children: [jsx(TextInput, {
+      label: 'Nome',
+      placeholder: 'Es: Etichettatrice 10x10',
+      onChange: v => setName(v.target.value)
+    }), jsx(TextInput, {
+      label: 'Descrizione',
+      placeholder: 'Es: Bancone area imballaggio',
+      onChange: v => setDescription(v.target.value)
+    }), jsx(Select, {
+      defaultValue: 'managed',
+      onChange: v => setPrinterType(v),
+      label: 'Tipo stampante',
+      data: [{
+        label: 'Stampante gestita',
+        value: 'managed'
+      }, {
+        label: 'Stampante non gestita',
+        value: 'unmanaged'
+      }]
+    }), printerType === 'unmanaged' ? jsxs(Fragment, {
+      children: [jsx(Select, {
+        onChange: v => setManufacturer(v),
+        label: 'Produttore',
+        data: [{
+          label: 'Zebra',
+          value: PrinterManufacturer.Zebra.toString()
+        }]
+      }), jsx(TextInput, {
+        onChange: v => setIpAddress(v.target.value),
+        label: 'Indirizzo IP',
+        placeholder: 'Es: 192.168.1.199'
+      }), jsx(NumberInput, {
+        onChange: v => setPort(+v),
+        label: 'Porta',
+        min: 1,
+        max: 65535,
+        placeholder: 'Es: 9100'
+      })]
+    }) : jsx(Select, {
+      onChange: v => setMappedPrinter(v),
+      leftSection: jsx(IconPrinter, {
+        size: 18
+      }),
+      label: 'Stampante fisica',
+      data: printers
+    }), jsxs(Group, {
+      justify: 'right',
+      children: [jsx(Button, {
+        onClick: () => props.onCanceled(),
+        variant: 'subtle',
+        children: "Annulla"
+      }), jsx(Button, {
+        onClick: submit,
+        disabled: !isValid(),
+        children: "Salva"
+      })]
+    })]
+  });
+}
+
+function ManagePrintServer(props) {
+  const [printServer, setPrintServer] = useState();
+  const [printServerLoaded, setPrintServerLoaded] = useState(false);
+  const [addPrinterModalOpened, setAddPrinterModalOpened] = useState(false);
+  const [name, setName] = useState();
+  const [description, setDescription] = useState();
+  useEffect(() => {
+    loadPrintServer();
+  }, []);
+  const loadPrintServer = () => {
+    setPrintServerLoaded(false);
+    FluxoClientSys.Instance.printing.GetPrintServer(props.printServerId).then(res => {
+      setPrintServer(res);
+      setName(res.name);
+      setDescription(res.description);
+      setPrintServerLoaded(true);
+    });
+  };
+  const updatePrintServerInfo = () => {
+    setPrintServerLoaded(false);
+    FluxoClientSys.Instance.printing.UpdatePrintServer(props.printServerId, {
+      name: name,
+      description: description
+    }).then(() => {
+      loadPrintServer();
+    });
+  };
+  return jsxs("div", {
+    children: [jsx(LoadingOverlay, {
+      visible: !printServerLoaded
+    }), jsxs(Stack, {
+      children: [jsxs(Group, {
+        grow: true,
+        children: [jsx(TextInput, {
+          disabled: true,
+          label: 'Tipo',
+          value: (printServer === null || printServer === void 0 ? void 0 : printServer.type) === PrintServerType.Direct ? 'Diretto' : 'Remoto'
+        }), jsx(TextInput, {
+          disabled: true,
+          label: 'Sistema di stampa',
+          value: (printServer === null || printServer === void 0 ? void 0 : printServer.managedType) === PrintServerManagedType.Ipp ? 'IPP / CUPS' : 'Windows'
+        })]
+      }), jsx(TextInput, {
+        label: 'Nome',
+        defaultValue: name,
+        onChange: v => setName(v.target.value)
+      }), jsx(TextInput, {
+        label: 'Descrizione',
+        defaultValue: description,
+        onChange: v => setDescription(v.target.value)
+      }), jsx(Group, {
+        justify: 'right',
+        align: 'center',
+        children: jsx(Button, {
+          onClick: updatePrintServerInfo,
+          disabled: (printServer === null || printServer === void 0 ? void 0 : printServer.name) === name && (printServer === null || printServer === void 0 ? void 0 : printServer.description) === description,
+          leftSection: jsx(IconRefresh, {
+            size: 18
+          }),
+          children: "Aggiorna"
+        })
+      }), jsx(DataCard, {
+        title: 'Stampanti',
+        icon: jsx(IconPrinter, {
+          size: 18
+        }),
+        actions: [{
+          icon: jsx(IconPlus, {
+            size: 18
+          }),
+          label: 'Aggiungi',
+          onClick: () => setAddPrinterModalOpened(true)
+        }],
+        children: (printServer === null || printServer === void 0 ? void 0 : printServer.printers.length) === 0 ? jsxs(Stack, {
+          children: [jsx(Text, {
+            children: "Non ci sono stampanti configurate"
+          }), jsx(Button, {
+            leftSection: jsx(IconPlus, {
+              size: 18
+            }),
+            onClick: () => setAddPrinterModalOpened(true),
+            children: "Aggiungi stampante"
+          })]
+        }) : jsx(Stack, {
+          children: printServer === null || printServer === void 0 ? void 0 : printServer.printers.map((p, i) => {
+            return jsxs(Group, {
+              justify: 'space-between',
+              style: {
+                border: '1px solid #ececec'
+              },
+              p: 8,
+              children: [jsxs(Stack, {
+                gap: 0,
+                children: [jsx(Text, {
+                  fw: 900,
+                  children: p.name
+                }), jsx(Text, {
+                  size: 'xs',
+                  children: p.description
+                })]
+              }), jsxs(Group, {
+                children: [p.type === PrinterType.Unmanaged && jsx(Text, {
+                  children: p.manufacturer === PrinterManufacturer.Zebra && jsx(Text, {
+                    fw: 900,
+                    style: {
+                      letterSpacing: '0.5px'
+                    },
+                    children: "ZEBRA"
+                  })
+                }), p.type === PrinterType.Managed && jsx(Text, {
+                  children: jsx(Text, {
+                    fw: 900,
+                    style: {
+                      letterSpacing: '0.5px'
+                    },
+                    children: p.mappedPrinterName
+                  })
+                }), p.type === PrinterType.Managed ? jsx(Badge, {
+                  color: 'blue',
+                  children: "Gestita"
+                }) : jsx(Badge, {
+                  color: 'yellow',
+                  children: "Non gestita"
+                }), jsxs(Menu, {
+                  children: [jsx(Menu.Target, {
+                    children: jsx(ActionIcon, {
+                      children: jsx(IconDotsVertical, {
+                        size: 18
+                      })
+                    })
+                  }), jsxs(Menu.Dropdown, {
+                    children: [jsx(Menu.Item, {
+                      children: "Modifica"
+                    }), jsx(Menu.Item, {
+                      color: 'red',
+                      children: "Elimina"
+                    })]
+                  })]
+                })]
+              })]
+            }, i);
+          })
+        })
+      }), jsx(Modal, {
+        title: `Aggiungi stampante - ${printServer === null || printServer === void 0 ? void 0 : printServer.name}`,
+        centered: true,
+        opened: addPrinterModalOpened,
+        onClose: () => setAddPrinterModalOpened(false),
+        children: jsx(AddPrinter, {
+          onCanceled: () => setAddPrinterModalOpened(false),
+          onSaved: () => {
+            setAddPrinterModalOpened(false);
+            loadPrintServer();
+          },
+          printServerId: props.printServerId
+        })
+      })]
+    })]
+  });
+}
+
+function PrintServerList() {
+  const [printServers, setPrintServers] = React.useState([]);
+  const [addPrintServerModalOpened, setPrintServerModalOpened] = React.useState(false);
+  const [currentPrintServer, setCurrentPrintServer] = React.useState();
+  const [managePrintServerModalOpened, setManagePrintServerModalOpened] = React.useState(false);
+  useEffect(() => {
+    loadPrintServer();
+  }, []);
+  const loadPrintServer = () => {
+    FluxoClientSys.Instance.printing.GetPrintServerList().then(a => {
+      setPrintServers(a);
+    });
+  };
+  return jsxs(DataCard, {
+    title: 'Print server virtuali',
+    actions: [{
+      icon: jsx(IconPlus, {
+        size: 18
+      }),
+      label: 'Nuovo',
+      onClick: () => setPrintServerModalOpened(true)
+    }],
+    children: [jsxs(Stack, {
+      children: [printServers.length === 0 && jsxs(Stack, {
+        mt: 16,
+        mb: 16,
+        children: [jsx(Center, {
+          children: jsx(Text, {
+            size: 'md',
+            children: "Nessun print server virtuale presente"
+          })
+        }), jsx(Center, {
+          children: jsx(Button, {
+            leftSection: jsx(IconPlus, {
+              size: 18
+            }),
+            onClick: () => setPrintServerModalOpened(true),
+            children: "Aggiungi un print server virtuale"
+          })
+        })]
+      }), printServers.map((e, i) => {
+        return jsxs(Group, {
+          align: "center",
+          justify: 'space-between',
+          style: {
+            border: '1px solid #ececec'
+          },
+          p: 8,
+          children: [jsxs(Group, {
+            align: 'center',
+            children: [jsx(IconCircle, {
+              size: 18,
+              color: '#329b0d',
+              fill: '#329b0d',
+              stroke: '#329b0d'
+            }), jsxs(Stack, {
+              gap: 0,
+              children: [jsx(Text, {
+                size: 'sm',
+                fw: 800,
+                children: e.name
+              }), jsx(Text, {
+                size: 'xs',
+                children: e.description
+              })]
+            })]
+          }), jsxs(Group, {
+            justify: 'right',
+            align: 'center',
+            gap: 16,
+            children: [e.managedType === PrintServerManagedType.Ipp && e.type === PrintServerType.Direct && jsxs(Badge, {
+              leftSection: jsx(IconExternalLink, {
+                style: {
+                  marginTop: 4
+                },
+                size: 16
+              }),
+              style: {
+                cursor: 'pointer'
+              },
+              color: 'yellow',
+              variant: 'light',
+              onClick: () => window.open(`http://${e.ipAddress}:${e.port}/`, '_blank'),
+              children: [e.ipAddress.toLowerCase(), ":", e.port]
+            }), e.managedType === PrintServerManagedType.Ipp && e.type === PrintServerType.Remote && jsxs(Badge, {
+              color: 'gray',
+              variant: 'light',
+              children: [e.ipAddress.toLowerCase(), ":", e.port]
+            }), e.type === PrintServerType.Direct ? jsx(IconLine, {
+              size: 18
+            }) : jsx(IconBuildingBridge, {
+              size: 18
+            }), e.managedType === PrintServerManagedType.Ipp ? jsx(Text, {
+              size: 'md',
+              fw: 900,
+              style: {
+                letterSpacing: '0.5px'
+              },
+              children: "IPP"
+            }) : jsx(IconBrandWindows, {
+              size: 18
+            }), jsxs(Menu, {
+              children: [jsx(Menu.Target, {
+                children: jsx(IconDotsVertical, {
+                  size: 18
+                })
+              }), jsxs(Menu.Dropdown, {
+                children: [jsx(Menu.Item, {
+                  leftSection: jsx(IconManualGearbox, {
+                    size: 18
+                  }),
+                  onClick: () => {
+                    setCurrentPrintServer(e);
+                    setManagePrintServerModalOpened(true);
+                  },
+                  children: "Gestisci"
+                }), jsx(Menu.Item, {
+                  children: "Disattiva"
+                }), jsx(Menu.Item, {
+                  children: "Attiva"
+                }), jsx(Menu.Divider, {}), jsx(Menu.Item, {
+                  color: 'red',
+                  leftSection: jsx(IconTrash, {
+                    size: 18
+                  }),
+                  children: "Elimina"
+                })]
+              })]
+            })]
+          })]
+        }, i);
+      })]
+    }), currentPrintServer && jsx(Drawer, {
+      title: 'Gestisci Print Server Virtuale',
+      size: 'lg',
+      position: 'right',
+      opened: managePrintServerModalOpened,
+      onClose: () => {
+        setManagePrintServerModalOpened(false);
+        loadPrintServer();
+      },
+      children: jsx(ManagePrintServer, {
+        printServerId: currentPrintServer === null || currentPrintServer === void 0 ? void 0 : currentPrintServer.id
+      })
+    }), jsx(Modal, {
+      title: 'Aggiungi Print Server Virtuale',
+      centered: true,
+      opened: addPrintServerModalOpened,
+      onClose: () => setPrintServerModalOpened(false),
+      children: jsx(AddPrintServer, {
+        onCanceled: () => setPrintServerModalOpened(false),
+        onSaved: () => {
+          setPrintServerModalOpened(false);
+          loadPrintServer();
+        }
+      })
+    })]
+  });
+}
+
+var isPrototypeOf$1 = objectIsPrototypeOf;
+
+var $TypeError$3 = TypeError;
+
+var anInstance$1 = function (it, Prototype) {
+  if (isPrototypeOf$1(Prototype, it)) return it;
+  throw new $TypeError$3('Incorrect invocation');
+};
+
+var DESCRIPTORS$1 = descriptors;
+var definePropertyModule = objectDefineProperty;
+var createPropertyDescriptor = createPropertyDescriptor$4;
+
+var createProperty$1 = function (object, key, value) {
+  if (DESCRIPTORS$1) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
+  else object[key] = value;
+};
+
+var $$1 = _export;
+var global$1 = global$e;
+var anInstance = anInstance$1;
+var anObject$3 = anObject$d;
+var isCallable = isCallable$g;
+var getPrototypeOf = objectGetPrototypeOf;
+var defineBuiltInAccessor = defineBuiltInAccessor$2;
+var createProperty = createProperty$1;
+var fails = fails$d;
+var hasOwn = hasOwnProperty_1;
+var wellKnownSymbol$2 = wellKnownSymbol$c;
+var IteratorPrototype = iteratorsCore.IteratorPrototype;
+var DESCRIPTORS = descriptors;
+
+var CONSTRUCTOR = 'constructor';
+var ITERATOR$2 = 'Iterator';
+var TO_STRING_TAG = wellKnownSymbol$2('toStringTag');
+
+var $TypeError$2 = TypeError;
+var NativeIterator = global$1[ITERATOR$2];
+
+// FF56- have non-standard global helper `Iterator`
+var FORCED = !isCallable(NativeIterator)
+  || NativeIterator.prototype !== IteratorPrototype
+  // FF44- non-standard `Iterator` passes previous tests
+  || !fails(function () { NativeIterator({}); });
+
+var IteratorConstructor = function Iterator() {
+  anInstance(this, IteratorPrototype);
+  if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError$2('Abstract class Iterator not directly constructable');
+};
+
+var defineIteratorPrototypeAccessor = function (key, value) {
+  if (DESCRIPTORS) {
+    defineBuiltInAccessor(IteratorPrototype, key, {
+      configurable: true,
+      get: function () {
+        return value;
+      },
+      set: function (replacement) {
+        anObject$3(this);
+        if (this === IteratorPrototype) throw new $TypeError$2("You can't redefine this property");
+        if (hasOwn(this, key)) this[key] = replacement;
+        else createProperty(this, key, replacement);
+      }
+    });
+  } else IteratorPrototype[key] = value;
+};
+
+if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR$2);
+
+if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) {
+  defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
+}
+
+IteratorConstructor.prototype = IteratorPrototype;
+
+// `Iterator` constructor
+// https://github.com/tc39/proposal-iterator-helpers
+$$1({ global: true, constructor: true, forced: FORCED }, {
+  Iterator: IteratorConstructor
+});
+
+var classofRaw = classofRaw$2;
+var uncurryThis$1 = functionUncurryThis;
+
+var functionUncurryThisClause = function (fn) {
+  // Nashorn bug:
+  //   https://github.com/zloirock/core-js/issues/1128
+  //   https://github.com/zloirock/core-js/issues/1130
+  if (classofRaw(fn) === 'Function') return uncurryThis$1(fn);
+};
+
+var uncurryThis = functionUncurryThisClause;
+var aCallable$2 = aCallable$6;
+var NATIVE_BIND = functionBindNative;
+
+var bind$1 = uncurryThis(uncurryThis.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable$2(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$1(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var wellKnownSymbol$1 = wellKnownSymbol$c;
+var Iterators$1 = iterators;
+
+var ITERATOR$1 = wellKnownSymbol$1('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$1] === it);
+};
+
+var classof = classof$2;
+var getMethod = getMethod$4;
+var isNullOrUndefined = isNullOrUndefined$3;
+var Iterators = iterators;
+var wellKnownSymbol = wellKnownSymbol$c;
+
+var ITERATOR = wellKnownSymbol('iterator');
+
+var getIteratorMethod$2 = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+    || getMethod(it, '@@iterator')
+    || Iterators[classof(it)];
+};
+
+var call$1 = functionCall;
+var aCallable$1 = aCallable$6;
+var anObject$2 = anObject$d;
+var tryToString$1 = tryToString$3;
+var getIteratorMethod$1 = getIteratorMethod$2;
+
+var $TypeError$1 = TypeError;
+
+var getIterator$1 = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
+  if (aCallable$1(iteratorMethod)) return anObject$2(call$1(iteratorMethod, argument));
+  throw new $TypeError$1(tryToString$1(argument) + ' is not iterable');
+};
+
+var bind = functionBindContext;
+var call = functionCall;
+var anObject$1 = anObject$d;
+var tryToString = tryToString$3;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var lengthOfArrayLike = lengthOfArrayLike$2;
+var isPrototypeOf = objectIsPrototypeOf;
+var getIterator = getIterator$1;
+var getIteratorMethod = getIteratorMethod$2;
+var iteratorClose = iteratorClose$3;
+
+var $TypeError = TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+var iterate$1 = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_RECORD = !!(options && options.IS_RECORD);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = bind(unboundFunction, that);
+  var iterator, iterFn, index, length, result, next, step;
+
+  var stop = function (condition) {
+    if (iterator) iteratorClose(iterator, 'normal', condition);
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      anObject$1(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_RECORD) {
+    iterator = iterable.iterator;
+  } else if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && isPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = IS_RECORD ? iterable.next : iterator.next;
+  while (!(step = call(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+var $ = _export;
+var iterate = iterate$1;
+var aCallable = aCallable$6;
+var anObject = anObject$d;
+var getIteratorDirect = getIteratorDirect$2;
+
+// `Iterator.prototype.find` method
+// https://github.com/tc39/proposal-iterator-helpers
+$({ target: 'Iterator', proto: true, real: true }, {
+  find: function find(predicate) {
+    anObject(this);
+    aCallable(predicate);
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    return iterate(record, function (value, stop) {
+      if (predicate(value, counter++)) return stop(value);
+    }, { IS_RECORD: true, INTERRUPTED: true }).result;
+  }
+});
+
+function PrinterChooser(props) {
+  const [printServersLoaded, setPrintServersLoaded] = useState(false);
+  const [selectedPrintServer, setSelectedPrintServer] = useState(null);
+  const [selectedPrinter, setSelectedPrinter] = useState(null);
+  const [printServerSelectItems, setPrintServerSelectItems] = useState([]);
+  const [printersSelectItems, setPrintersSelectItems] = useState([]);
+  const [virtualPrintServers, setVirtualPrintServers] = useState([]);
+  const [onPrinting, setOnPrinting] = useState(false);
+  useEffect(() => {
+    FluxoClientSys.Instance.printing.GetPrintServerList().then(printServers => {
+      setVirtualPrintServers(printServers);
+      const printServerSelectItems = printServers.map(printServer => {
+        return {
+          value: printServer.id.toString(),
+          label: printServer.name
+        };
+      });
+      setPrintServerSelectItems(printServerSelectItems);
+      setSelectedPrintServer(printServers[0].id.toString());
+      setPrintServersLoaded(true);
+    });
+  }, []);
+  useEffect(() => {
+    setPrintersSelectItems([]);
+    if (!selectedPrintServer) {
+      return;
+    }
+    const ps = virtualPrintServers.find(ps => ps.id.toString() === selectedPrintServer);
+    if (!ps) return;
+    setPrintersSelectItems(ps === null || ps === void 0 ? void 0 : ps.printers.map(printer => {
+      return {
+        value: printer.id.toString(),
+        label: printer.name
+      };
+    }));
+    if (ps.printers.length > 0) setSelectedPrinter(ps.printers[0].id.toString());
+  }, [selectedPrintServer]);
+  const print = () => {
+    if (!selectedPrinter || !selectedPrintServer) {
+      return;
+    }
+    const command = {
+      reportUrl: props.reportUrl,
+      virtualPrinterId: +selectedPrinter,
+      virtualServerId: +selectedPrintServer
+    };
+    setOnPrinting(true);
+    FluxoClientSys.Instance.reporting.print(command).then(() => {
+      showNotification({
+        title: 'Stampa avviata',
+        message: 'La stampa è stata avviata correttamente',
+        color: 'success'
+      });
+      setOnPrinting(false);
+      props.onPrintFinished();
+    }).catch(err => {
+      showNotification({
+        title: 'Errore',
+        message: err.message,
+        color: 'danger'
+      });
+      setOnPrinting(false);
+    });
+  };
+  return jsx(Fragment, {
+    children: printServersLoaded ? jsxs(Stack, {
+      children: [jsx(Select, {
+        disabled: onPrinting,
+        value: selectedPrintServer,
+        onChange: setSelectedPrintServer,
+        data: printServerSelectItems,
+        label: 'Server di stampa'
+      }), jsx(Select, {
+        disabled: onPrinting,
+        data: printersSelectItems,
+        value: selectedPrinter,
+        onChange: setSelectedPrinter,
+        label: 'Stampante'
+      }), jsxs(Group, {
+        justify: 'right',
+        align: 'center',
+        children: [jsx(Button, {
+          variant: 'subtle',
+          disabled: onPrinting,
+          onClick: props.onCancel,
+          children: "Annulla"
+        }), jsx(Button, {
+          disabled: onPrinting,
+          onClick: print,
+          leftSection: jsx(IconPrinter, {
+            size: 18
+          }),
+          children: "Stampa"
+        })]
+      })]
+    }) : jsx(Box, {
+      h: 171,
+      children: jsx(Center, {
+        children: jsx(Loader, {})
+      })
+    })
+  });
+}
+
+export { PrintServerList, PrinterChooser };