@fluxo-dev/api-client-base 0.0.13 → 0.0.15

package/index.cjs.js

@@ -0,0 +1,2825 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var state = require('@fluxo-dev/state');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var check = function (it) {
+  return it && it.Math == Math && it;
+};
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global$h =
+  // eslint-disable-next-line no-undef
+  check(typeof globalThis == 'object' && globalThis) ||
+  check(typeof window == 'object' && window) ||
+  check(typeof self == 'object' && self) ||
+  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+  // eslint-disable-next-line no-new-func
+  Function('return this')();
+
+var objectGetOwnPropertyDescriptor = {};
+
+var fails$8 = function (exec) {
+  try {
+    return !!exec();
+  } catch (error) {
+    return true;
+  }
+};
+
+var fails$7 = fails$8;
+
+// Thank's IE8 for his funny defineProperty
+var descriptors = !fails$7(function () {
+  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
+});
+
+var objectPropertyIsEnumerable = {};
+
+var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
+var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
+
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor$2 && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
+
+// `Object.prototype.propertyIsEnumerable` method implementation
+// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable
+objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+  var descriptor = getOwnPropertyDescriptor$2(this, V);
+  return !!descriptor && descriptor.enumerable;
+} : nativePropertyIsEnumerable;
+
+var createPropertyDescriptor$2 = function (bitmap, value) {
+  return {
+    enumerable: !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable: !(bitmap & 4),
+    value: value
+  };
+};
+
+var toString = {}.toString;
+
+var classofRaw$1 = function (it) {
+  return toString.call(it).slice(8, -1);
+};
+
+var fails$6 = fails$8;
+var classof$7 = classofRaw$1;
+
+var split = ''.split;
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var indexedObject = fails$6(function () {
+  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+  // eslint-disable-next-line no-prototype-builtins
+  return !Object('z').propertyIsEnumerable(0);
+}) ? function (it) {
+  return classof$7(it) == 'String' ? split.call(it, '') : Object(it);
+} : Object;
+
+// `RequireObjectCoercible` abstract operation
+// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
+var requireObjectCoercible$3 = function (it) {
+  if (it == undefined) throw TypeError("Can't call method on " + it);
+  return it;
+};
+
+// toObject with fallback for non-array-like ES3 strings
+var IndexedObject$1 = indexedObject;
+var requireObjectCoercible$2 = requireObjectCoercible$3;
+
+var toIndexedObject$3 = function (it) {
+  return IndexedObject$1(requireObjectCoercible$2(it));
+};
+
+var isObject$8 = function (it) {
+  return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+
+var isObject$7 = isObject$8;
+
+// `ToPrimitive` abstract operation
+// https://tc39.github.io/ecma262/#sec-toprimitive
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+var toPrimitive$2 = function (input, PREFERRED_STRING) {
+  if (!isObject$7(input)) return input;
+  var fn, val;
+  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject$7(val = fn.call(input))) return val;
+  if (typeof (fn = input.valueOf) == 'function' && !isObject$7(val = fn.call(input))) return val;
+  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject$7(val = fn.call(input))) return val;
+  throw TypeError("Can't convert object to primitive value");
+};
+
+var hasOwnProperty = {}.hasOwnProperty;
+
+var has$8 = function (it, key) {
+  return hasOwnProperty.call(it, key);
+};
+
+var global$g = global$h;
+var isObject$6 = isObject$8;
+
+var document$2 = global$g.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS = isObject$6(document$2) && isObject$6(document$2.createElement);
+
+var documentCreateElement$1 = function (it) {
+  return EXISTS ? document$2.createElement(it) : {};
+};
+
+var DESCRIPTORS$7 = descriptors;
+var fails$5 = fails$8;
+var createElement$1 = documentCreateElement$1;
+
+// Thank's IE8 for his funny defineProperty
+var ie8DomDefine = !DESCRIPTORS$7 && !fails$5(function () {
+  return Object.defineProperty(createElement$1('div'), 'a', {
+    get: function () { return 7; }
+  }).a != 7;
+});
+
+var DESCRIPTORS$6 = descriptors;
+var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
+var createPropertyDescriptor$1 = createPropertyDescriptor$2;
+var toIndexedObject$2 = toIndexedObject$3;
+var toPrimitive$1 = toPrimitive$2;
+var has$7 = has$8;
+var IE8_DOM_DEFINE$1 = ie8DomDefine;
+
+var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
+objectGetOwnPropertyDescriptor.f = DESCRIPTORS$6 ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+  O = toIndexedObject$2(O);
+  P = toPrimitive$1(P, true);
+  if (IE8_DOM_DEFINE$1) try {
+    return nativeGetOwnPropertyDescriptor(O, P);
+  } catch (error) { /* empty */ }
+  if (has$7(O, P)) return createPropertyDescriptor$1(!propertyIsEnumerableModule$1.f.call(O, P), O[P]);
+};
+
+var objectDefineProperty = {};
+
+var isObject$5 = isObject$8;
+
+var anObject$8 = function (it) {
+  if (!isObject$5(it)) {
+    throw TypeError(String(it) + ' is not an object');
+  } return it;
+};
+
+var DESCRIPTORS$5 = descriptors;
+var IE8_DOM_DEFINE = ie8DomDefine;
+var anObject$7 = anObject$8;
+var toPrimitive = toPrimitive$2;
+
+var nativeDefineProperty = Object.defineProperty;
+
+// `Object.defineProperty` method
+// https://tc39.github.io/ecma262/#sec-object.defineproperty
+objectDefineProperty.f = DESCRIPTORS$5 ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
+  anObject$7(O);
+  P = toPrimitive(P, true);
+  anObject$7(Attributes);
+  if (IE8_DOM_DEFINE) try {
+    return nativeDefineProperty(O, P, Attributes);
+  } catch (error) { /* empty */ }
+  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};
+
+var DESCRIPTORS$4 = descriptors;
+var definePropertyModule$4 = objectDefineProperty;
+var createPropertyDescriptor = createPropertyDescriptor$2;
+
+var createNonEnumerableProperty$4 = DESCRIPTORS$4 ? function (object, key, value) {
+  return definePropertyModule$4.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+  object[key] = value;
+  return object;
+};
+
+var redefine$3 = {exports: {}};
+
+var global$f = global$h;
+var createNonEnumerableProperty$3 = createNonEnumerableProperty$4;
+
+var setGlobal$3 = function (key, value) {
+  try {
+    createNonEnumerableProperty$3(global$f, key, value);
+  } catch (error) {
+    global$f[key] = value;
+  } return value;
+};
+
+var global$e = global$h;
+var setGlobal$2 = setGlobal$3;
+
+var SHARED = '__core-js_shared__';
+var store$3 = global$e[SHARED] || setGlobal$2(SHARED, {});
+
+var sharedStore = store$3;
+
+var store$2 = sharedStore;
+
+var functionToString = Function.toString;
+
+// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
+if (typeof store$2.inspectSource != 'function') {
+  store$2.inspectSource = function (it) {
+    return functionToString.call(it);
+  };
+}
+
+var inspectSource$3 = store$2.inspectSource;
+
+var global$d = global$h;
+var inspectSource$2 = inspectSource$3;
+
+var WeakMap$1 = global$d.WeakMap;
+
+var nativeWeakMap = typeof WeakMap$1 === 'function' && /native code/.test(inspectSource$2(WeakMap$1));
+
+var shared$2 = {exports: {}};
+
+var store$1 = sharedStore;
+
+(shared$2.exports = function (key, value) {
+  return store$1[key] || (store$1[key] = value !== undefined ? value : {});
+})('versions', []).push({
+  version: '3.6.5',
+  mode: 'global',
+  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
+});
+
+var id = 0;
+var postfix = Math.random();
+
+var uid$2 = function (key) {
+  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
+};
+
+var shared$1 = shared$2.exports;
+var uid$1 = uid$2;
+
+var keys = shared$1('keys');
+
+var sharedKey$2 = function (key) {
+  return keys[key] || (keys[key] = uid$1(key));
+};
+
+var hiddenKeys$4 = {};
+
+var NATIVE_WEAK_MAP = nativeWeakMap;
+var global$c = global$h;
+var isObject$4 = isObject$8;
+var createNonEnumerableProperty$2 = createNonEnumerableProperty$4;
+var objectHas = has$8;
+var sharedKey$1 = sharedKey$2;
+var hiddenKeys$3 = hiddenKeys$4;
+
+var WeakMap = global$c.WeakMap;
+var set$1, get, has$6;
+
+var enforce = function (it) {
+  return has$6(it) ? get(it) : set$1(it, {});
+};
+
+var getterFor = function (TYPE) {
+  return function (it) {
+    var state;
+    if (!isObject$4(it) || (state = get(it)).type !== TYPE) {
+      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
+    } return state;
+  };
+};
+
+if (NATIVE_WEAK_MAP) {
+  var store = new WeakMap();
+  var wmget = store.get;
+  var wmhas = store.has;
+  var wmset = store.set;
+  set$1 = function (it, metadata) {
+    wmset.call(store, it, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return wmget.call(store, it) || {};
+  };
+  has$6 = function (it) {
+    return wmhas.call(store, it);
+  };
+} else {
+  var STATE = sharedKey$1('state');
+  hiddenKeys$3[STATE] = true;
+  set$1 = function (it, metadata) {
+    createNonEnumerableProperty$2(it, STATE, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return objectHas(it, STATE) ? it[STATE] : {};
+  };
+  has$6 = function (it) {
+    return objectHas(it, STATE);
+  };
+}
+
+var internalState = {
+  set: set$1,
+  get: get,
+  has: has$6,
+  enforce: enforce,
+  getterFor: getterFor
+};
+
+var global$b = global$h;
+var createNonEnumerableProperty$1 = createNonEnumerableProperty$4;
+var has$5 = has$8;
+var setGlobal$1 = setGlobal$3;
+var inspectSource$1 = inspectSource$3;
+var InternalStateModule$1 = internalState;
+
+var getInternalState$1 = InternalStateModule$1.get;
+var enforceInternalState = InternalStateModule$1.enforce;
+var TEMPLATE = String(String).split('String');
+
+(redefine$3.exports = function (O, key, value, options) {
+  var unsafe = options ? !!options.unsafe : false;
+  var simple = options ? !!options.enumerable : false;
+  var noTargetGet = options ? !!options.noTargetGet : false;
+  if (typeof value == 'function') {
+    if (typeof key == 'string' && !has$5(value, 'name')) createNonEnumerableProperty$1(value, 'name', key);
+    enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
+  }
+  if (O === global$b) {
+    if (simple) O[key] = value;
+    else setGlobal$1(key, value);
+    return;
+  } else if (!unsafe) {
+    delete O[key];
+  } else if (!noTargetGet && O[key]) {
+    simple = true;
+  }
+  if (simple) O[key] = value;
+  else createNonEnumerableProperty$1(O, key, value);
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+})(Function.prototype, 'toString', function toString() {
+  return typeof this == 'function' && getInternalState$1(this).source || inspectSource$1(this);
+});
+
+var global$a = global$h;
+
+var path$1 = global$a;
+
+var path = path$1;
+var global$9 = global$h;
+
+var aFunction$5 = function (variable) {
+  return typeof variable == 'function' ? variable : undefined;
+};
+
+var getBuiltIn$5 = function (namespace, method) {
+  return arguments.length < 2 ? aFunction$5(path[namespace]) || aFunction$5(global$9[namespace])
+    : path[namespace] && path[namespace][method] || global$9[namespace] && global$9[namespace][method];
+};
+
+var objectGetOwnPropertyNames = {};
+
+var ceil = Math.ceil;
+var floor = Math.floor;
+
+// `ToInteger` abstract operation
+// https://tc39.github.io/ecma262/#sec-tointeger
+var toInteger$3 = function (argument) {
+  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
+};
+
+var toInteger$2 = toInteger$3;
+
+var min$1 = Math.min;
+
+// `ToLength` abstract operation
+// https://tc39.github.io/ecma262/#sec-tolength
+var toLength$4 = function (argument) {
+  return argument > 0 ? min$1(toInteger$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+
+var toInteger$1 = toInteger$3;
+
+var max = Math.max;
+var min = 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 = toInteger$1(index);
+  return integer < 0 ? max(integer + length, 0) : min(integer, length);
+};
+
+var toIndexedObject$1 = toIndexedObject$3;
+var toLength$3 = toLength$4;
+var toAbsoluteIndex = toAbsoluteIndex$1;
+
+// `Array.prototype.{ indexOf, includes }` methods implementation
+var createMethod = function (IS_INCLUDES) {
+  return function ($this, el, fromIndex) {
+    var O = toIndexedObject$1($this);
+    var length = toLength$3(O.length);
+    var index = toAbsoluteIndex(fromIndex, length);
+    var value;
+    // Array#includes uses SameValueZero equality algorithm
+    // eslint-disable-next-line no-self-compare
+    if (IS_INCLUDES && el != el) while (length > index) {
+      value = O[index++];
+      // eslint-disable-next-line no-self-compare
+      if (value != value) return true;
+    // Array#indexOf ignores holes, Array#includes - not
+    } else for (;length > index; index++) {
+      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+    } return !IS_INCLUDES && -1;
+  };
+};
+
+var arrayIncludes = {
+  // `Array.prototype.includes` method
+  // https://tc39.github.io/ecma262/#sec-array.prototype.includes
+  includes: createMethod(true),
+  // `Array.prototype.indexOf` method
+  // https://tc39.github.io/ecma262/#sec-array.prototype.indexof
+  indexOf: createMethod(false)
+};
+
+var has$4 = has$8;
+var toIndexedObject = toIndexedObject$3;
+var indexOf = arrayIncludes.indexOf;
+var hiddenKeys$2 = hiddenKeys$4;
+
+var objectKeysInternal = function (object, names) {
+  var O = toIndexedObject(object);
+  var i = 0;
+  var result = [];
+  var key;
+  for (key in O) !has$4(hiddenKeys$2, key) && has$4(O, key) && result.push(key);
+  // Don't enum bug & hidden keys
+  while (names.length > i) if (has$4(O, key = names[i++])) {
+    ~indexOf(result, key) || result.push(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.github.io/ecma262/#sec-object.getownpropertynames
+objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+  return internalObjectKeys$1(O, hiddenKeys$1);
+};
+
+var objectGetOwnPropertySymbols = {};
+
+objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
+
+var getBuiltIn$4 = getBuiltIn$5;
+var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
+var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
+var anObject$6 = anObject$8;
+
+// all object keys, includes non-enumerable and symbols
+var ownKeys$1 = getBuiltIn$4('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = getOwnPropertyNamesModule.f(anObject$6(it));
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
+  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
+};
+
+var has$3 = has$8;
+var ownKeys = ownKeys$1;
+var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
+var definePropertyModule$3 = objectDefineProperty;
+
+var copyConstructorProperties$1 = function (target, source) {
+  var keys = ownKeys(source);
+  var defineProperty = definePropertyModule$3.f;
+  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!has$3(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+  }
+};
+
+var fails$4 = fails$8;
+
+var replacement = /#|\.prototype\./;
+
+var isForced$2 = function (feature, detection) {
+  var value = data[normalize(feature)];
+  return value == POLYFILL ? true
+    : value == NATIVE ? false
+    : typeof detection == 'function' ? fails$4(detection)
+    : !!detection;
+};
+
+var normalize = isForced$2.normalize = function (string) {
+  return String(string).replace(replacement, '.').toLowerCase();
+};
+
+var data = isForced$2.data = {};
+var NATIVE = isForced$2.NATIVE = 'N';
+var POLYFILL = isForced$2.POLYFILL = 'P';
+
+var isForced_1 = isForced$2;
+
+var global$8 = global$h;
+var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
+var createNonEnumerableProperty = createNonEnumerableProperty$4;
+var redefine$2 = redefine$3.exports;
+var setGlobal = setGlobal$3;
+var copyConstructorProperties = copyConstructorProperties$1;
+var isForced$1 = 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.noTargetGet - prevent calling a getter on target
+*/
+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$8;
+  } else if (STATIC) {
+    target = global$8[TARGET] || setGlobal(TARGET, {});
+  } else {
+    target = (global$8[TARGET] || {}).prototype;
+  }
+  if (target) for (key in source) {
+    sourceProperty = source[key];
+    if (options.noTargetGet) {
+      descriptor = getOwnPropertyDescriptor$1(target, key);
+      targetProperty = descriptor && descriptor.value;
+    } else targetProperty = target[key];
+    FORCED = isForced$1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+    // contained in target
+    if (!FORCED && targetProperty !== undefined) {
+      if (typeof sourceProperty === typeof targetProperty) continue;
+      copyConstructorProperties(sourceProperty, targetProperty);
+    }
+    // add a flag to not completely full polyfills
+    if (options.sham || (targetProperty && targetProperty.sham)) {
+      createNonEnumerableProperty(sourceProperty, 'sham', true);
+    }
+    // extend global
+    redefine$2(target, key, sourceProperty, options);
+  }
+};
+
+var internalObjectKeys = objectKeysInternal;
+var enumBugKeys$1 = enumBugKeys$3;
+
+// `Object.keys` method
+// https://tc39.github.io/ecma262/#sec-object.keys
+var objectKeys$2 = Object.keys || function keys(O) {
+  return internalObjectKeys(O, enumBugKeys$1);
+};
+
+var requireObjectCoercible$1 = requireObjectCoercible$3;
+
+// `ToObject` abstract operation
+// https://tc39.github.io/ecma262/#sec-toobject
+var toObject$2 = function (argument) {
+  return Object(requireObjectCoercible$1(argument));
+};
+
+var DESCRIPTORS$3 = descriptors;
+var fails$3 = fails$8;
+var objectKeys$1 = objectKeys$2;
+var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
+var propertyIsEnumerableModule = objectPropertyIsEnumerable;
+var toObject$1 = toObject$2;
+var IndexedObject = indexedObject;
+
+var nativeAssign = Object.assign;
+var defineProperty$2 = Object.defineProperty;
+
+// `Object.assign` method
+// https://tc39.github.io/ecma262/#sec-object.assign
+var objectAssign = !nativeAssign || fails$3(function () {
+  // should have correct order of operations (Edge bug)
+  if (DESCRIPTORS$3 && nativeAssign({ b: 1 }, nativeAssign(defineProperty$2({}, 'a', {
+    enumerable: true,
+    get: function () {
+      defineProperty$2(this, 'b', {
+        value: 3,
+        enumerable: false
+      });
+    }
+  }), { b: 2 })).b !== 1) return true;
+  // should work with symbols and should have deterministic property order (V8 bug)
+  var A = {};
+  var B = {};
+  // eslint-disable-next-line no-undef
+  var symbol = Symbol();
+  var alphabet = 'abcdefghijklmnopqrst';
+  A[symbol] = 7;
+  alphabet.split('').forEach(function (chr) { B[chr] = chr; });
+  return nativeAssign({}, A)[symbol] != 7 || objectKeys$1(nativeAssign({}, B)).join('') != alphabet;
+}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
+  var T = toObject$1(target);
+  var argumentsLength = arguments.length;
+  var index = 1;
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+  var propertyIsEnumerable = propertyIsEnumerableModule.f;
+  while (argumentsLength > index) {
+    var S = IndexedObject(arguments[index++]);
+    var keys = getOwnPropertySymbols ? objectKeys$1(S).concat(getOwnPropertySymbols(S)) : objectKeys$1(S);
+    var length = keys.length;
+    var j = 0;
+    var key;
+    while (length > j) {
+      key = keys[j++];
+      if (!DESCRIPTORS$3 || propertyIsEnumerable.call(S, key)) T[key] = S[key];
+    }
+  } return T;
+} : nativeAssign;
+
+var $$4 = _export;
+var assign = objectAssign;
+
+// `Object.assign` method
+// https://tc39.github.io/ecma262/#sec-object.assign
+$$4({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
+  assign: assign
+});
+
+var global$7 = global$h;
+
+var nativePromiseConstructor = global$7.Promise;
+
+var redefine$1 = redefine$3.exports;
+
+var redefineAll$1 = function (target, src, options) {
+  for (var key in src) redefine$1(target, key, src[key], options);
+  return target;
+};
+
+var fails$2 = fails$8;
+
+var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$2(function () {
+  // Chrome 38 Symbol has incorrect toString conversion
+  // eslint-disable-next-line no-undef
+  return !String(Symbol());
+});
+
+var NATIVE_SYMBOL$1 = nativeSymbol;
+
+var useSymbolAsUid = NATIVE_SYMBOL$1
+  // eslint-disable-next-line no-undef
+  && !Symbol.sham
+  // eslint-disable-next-line no-undef
+  && typeof Symbol.iterator == 'symbol';
+
+var global$6 = global$h;
+var shared = shared$2.exports;
+var has$2 = has$8;
+var uid = uid$2;
+var NATIVE_SYMBOL = nativeSymbol;
+var USE_SYMBOL_AS_UID = useSymbolAsUid;
+
+var WellKnownSymbolsStore = shared('wks');
+var Symbol$1 = global$6.Symbol;
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;
+
+var wellKnownSymbol$d = function (name) {
+  if (!has$2(WellKnownSymbolsStore, name)) {
+    if (NATIVE_SYMBOL && has$2(Symbol$1, name)) WellKnownSymbolsStore[name] = Symbol$1[name];
+    else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
+  } return WellKnownSymbolsStore[name];
+};
+
+var defineProperty$1 = objectDefineProperty.f;
+var has$1 = has$8;
+var wellKnownSymbol$c = wellKnownSymbol$d;
+
+var TO_STRING_TAG$2 = wellKnownSymbol$c('toStringTag');
+
+var setToStringTag$1 = function (it, TAG, STATIC) {
+  if (it && !has$1(it = STATIC ? it : it.prototype, TO_STRING_TAG$2)) {
+    defineProperty$1(it, TO_STRING_TAG$2, { configurable: true, value: TAG });
+  }
+};
+
+var getBuiltIn$3 = getBuiltIn$5;
+var definePropertyModule$2 = objectDefineProperty;
+var wellKnownSymbol$b = wellKnownSymbol$d;
+var DESCRIPTORS$2 = descriptors;
+
+var SPECIES$3 = wellKnownSymbol$b('species');
+
+var setSpecies$1 = function (CONSTRUCTOR_NAME) {
+  var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
+  var defineProperty = definePropertyModule$2.f;
+
+  if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$3]) {
+    defineProperty(Constructor, SPECIES$3, {
+      configurable: true,
+      get: function () { return this; }
+    });
+  }
+};
+
+var aFunction$4 = function (it) {
+  if (typeof it != 'function') {
+    throw TypeError(String(it) + ' is not a function');
+  } return it;
+};
+
+var anInstance$1 = function (it, Constructor, name) {
+  if (!(it instanceof Constructor)) {
+    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
+  } return it;
+};
+
+var iterate$2 = {exports: {}};
+
+var iterators = {};
+
+var wellKnownSymbol$a = wellKnownSymbol$d;
+var Iterators$1 = iterators;
+
+var ITERATOR$2 = wellKnownSymbol$a('iterator');
+var ArrayPrototype$1 = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype$1[ITERATOR$2] === it);
+};
+
+var aFunction$3 = aFunction$4;
+
+// optional / simple context binding
+var functionBindContext = function (fn, that, length) {
+  aFunction$3(fn);
+  if (that === undefined) return fn;
+  switch (length) {
+    case 0: return function () {
+      return fn.call(that);
+    };
+    case 1: return function (a) {
+      return fn.call(that, a);
+    };
+    case 2: return function (a, b) {
+      return fn.call(that, a, b);
+    };
+    case 3: return function (a, b, c) {
+      return fn.call(that, a, b, c);
+    };
+  }
+  return function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var wellKnownSymbol$9 = wellKnownSymbol$d;
+
+var TO_STRING_TAG$1 = wellKnownSymbol$9('toStringTag');
+var test = {};
+
+test[TO_STRING_TAG$1] = 'z';
+
+var toStringTagSupport = String(test) === '[object z]';
+
+var TO_STRING_TAG_SUPPORT = toStringTagSupport;
+var classofRaw = classofRaw$1;
+var wellKnownSymbol$8 = wellKnownSymbol$d;
+
+var TO_STRING_TAG = wellKnownSymbol$8('toStringTag');
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw(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$6 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+  var O, tag, result;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
+    // builtinTag case
+    : CORRECT_ARGUMENTS ? classofRaw(O)
+    // ES3 arguments fallback
+    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
+};
+
+var classof$5 = classof$6;
+var Iterators = iterators;
+var wellKnownSymbol$7 = wellKnownSymbol$d;
+
+var ITERATOR$1 = wellKnownSymbol$7('iterator');
+
+var getIteratorMethod$1 = function (it) {
+  if (it != undefined) return it[ITERATOR$1]
+    || it['@@iterator']
+    || Iterators[classof$5(it)];
+};
+
+var anObject$5 = anObject$8;
+
+// call something on iterator step with safe closing on error
+var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) {
+  try {
+    return ENTRIES ? fn(anObject$5(value)[0], value[1]) : fn(value);
+  // 7.4.6 IteratorClose(iterator, completion)
+  } catch (error) {
+    var returnMethod = iterator['return'];
+    if (returnMethod !== undefined) anObject$5(returnMethod.call(iterator));
+    throw error;
+  }
+};
+
+var anObject$4 = anObject$8;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var toLength$2 = toLength$4;
+var bind$3 = functionBindContext;
+var getIteratorMethod = getIteratorMethod$1;
+var callWithSafeIterationClosing = callWithSafeIterationClosing$1;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var iterate$1 = iterate$2.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) {
+  var boundFunction = bind$3(fn, that, AS_ENTRIES ? 2 : 1);
+  var iterator, iterFn, index, length, result, next, step;
+
+  if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (typeof iterFn != 'function') throw TypeError('Target is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = toLength$2(iterable.length); length > index; index++) {
+        result = AS_ENTRIES
+          ? boundFunction(anObject$4(step = iterable[index])[0], step[1])
+          : boundFunction(iterable[index]);
+        if (result && result instanceof Result) return result;
+      } return new Result(false);
+    }
+    iterator = iterFn.call(iterable);
+  }
+
+  next = iterator.next;
+  while (!(step = next.call(iterator)).done) {
+    result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES);
+    if (typeof result == 'object' && result && result instanceof Result) return result;
+  } return new Result(false);
+};
+
+iterate$1.stop = function (result) {
+  return new Result(true, result);
+};
+
+var wellKnownSymbol$6 = wellKnownSymbol$d;
+
+var ITERATOR = wellKnownSymbol$6('iterator');
+var SAFE_CLOSING = false;
+
+try {
+  var called = 0;
+  var iteratorWithReturn = {
+    next: function () {
+      return { done: !!called++ };
+    },
+    'return': function () {
+      SAFE_CLOSING = true;
+    }
+  };
+  iteratorWithReturn[ITERATOR] = function () {
+    return this;
+  };
+  // eslint-disable-next-line no-throw-literal
+  Array.from(iteratorWithReturn, function () { throw 2; });
+} catch (error) { /* empty */ }
+
+var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
+  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+  var ITERATION_SUPPORT = false;
+  try {
+    var object = {};
+    object[ITERATOR] = function () {
+      return {
+        next: function () {
+          return { done: ITERATION_SUPPORT = true };
+        }
+      };
+    };
+    exec(object);
+  } catch (error) { /* empty */ }
+  return ITERATION_SUPPORT;
+};
+
+var anObject$3 = anObject$8;
+var aFunction$2 = aFunction$4;
+var wellKnownSymbol$5 = wellKnownSymbol$d;
+
+var SPECIES$2 = wellKnownSymbol$5('species');
+
+// `SpeciesConstructor` abstract operation
+// https://tc39.github.io/ecma262/#sec-speciesconstructor
+var speciesConstructor$1 = function (O, defaultConstructor) {
+  var C = anObject$3(O).constructor;
+  var S;
+  return C === undefined || (S = anObject$3(C)[SPECIES$2]) == undefined ? defaultConstructor : aFunction$2(S);
+};
+
+var getBuiltIn$2 = getBuiltIn$5;
+
+var html$2 = getBuiltIn$2('document', 'documentElement');
+
+var getBuiltIn$1 = getBuiltIn$5;
+
+var engineUserAgent = getBuiltIn$1('navigator', 'userAgent') || '';
+
+var userAgent$1 = engineUserAgent;
+
+var engineIsIos = /(iphone|ipod|ipad).*applewebkit/i.test(userAgent$1);
+
+var global$5 = global$h;
+var fails$1 = fails$8;
+var classof$4 = classofRaw$1;
+var bind$2 = functionBindContext;
+var html$1 = html$2;
+var createElement = documentCreateElement$1;
+var IS_IOS$1 = engineIsIos;
+
+var location = global$5.location;
+var set = global$5.setImmediate;
+var clear = global$5.clearImmediate;
+var process$3 = global$5.process;
+var MessageChannel = global$5.MessageChannel;
+var Dispatch = global$5.Dispatch;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var defer, channel, port;
+
+var run = function (id) {
+  // eslint-disable-next-line no-prototype-builtins
+  if (queue.hasOwnProperty(id)) {
+    var fn = queue[id];
+    delete queue[id];
+    fn();
+  }
+};
+
+var runner = function (id) {
+  return function () {
+    run(id);
+  };
+};
+
+var listener = function (event) {
+  run(event.data);
+};
+
+var post = function (id) {
+  // old engines have not location.origin
+  global$5.postMessage(id + '', location.protocol + '//' + location.host);
+};
+
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if (!set || !clear) {
+  set = function setImmediate(fn) {
+    var args = [];
+    var i = 1;
+    while (arguments.length > i) args.push(arguments[i++]);
+    queue[++counter] = function () {
+      // eslint-disable-next-line no-new-func
+      (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
+    };
+    defer(counter);
+    return counter;
+  };
+  clear = function clearImmediate(id) {
+    delete queue[id];
+  };
+  // Node.js 0.8-
+  if (classof$4(process$3) == 'process') {
+    defer = function (id) {
+      process$3.nextTick(runner(id));
+    };
+  // Sphere (JS game engine) Dispatch API
+  } else if (Dispatch && Dispatch.now) {
+    defer = function (id) {
+      Dispatch.now(runner(id));
+    };
+  // Browsers with MessageChannel, includes WebWorkers
+  // except iOS - https://github.com/zloirock/core-js/issues/624
+  } else if (MessageChannel && !IS_IOS$1) {
+    channel = new MessageChannel();
+    port = channel.port2;
+    channel.port1.onmessage = listener;
+    defer = bind$2(port.postMessage, port, 1);
+  // Browsers with postMessage, skip WebWorkers
+  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+  } else if (
+    global$5.addEventListener &&
+    typeof postMessage == 'function' &&
+    !global$5.importScripts &&
+    !fails$1(post) &&
+    location.protocol !== 'file:'
+  ) {
+    defer = post;
+    global$5.addEventListener('message', listener, false);
+  // IE8-
+  } else if (ONREADYSTATECHANGE in createElement('script')) {
+    defer = function (id) {
+      html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
+        html$1.removeChild(this);
+        run(id);
+      };
+    };
+  // Rest old browsers
+  } else {
+    defer = function (id) {
+      setTimeout(runner(id), 0);
+    };
+  }
+}
+
+var task$1 = {
+  set: set,
+  clear: clear
+};
+
+var global$4 = global$h;
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+var classof$3 = classofRaw$1;
+var macrotask = task$1.set;
+var IS_IOS = engineIsIos;
+
+var MutationObserver = global$4.MutationObserver || global$4.WebKitMutationObserver;
+var process$2 = global$4.process;
+var Promise$1 = global$4.Promise;
+var IS_NODE$1 = classof$3(process$2) == 'process';
+// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
+var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$4, 'queueMicrotask');
+var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
+
+var flush, head, last, notify$1, toggle, node, promise, then;
+
+// modern engines have queueMicrotask method
+if (!queueMicrotask) {
+  flush = function () {
+    var parent, fn;
+    if (IS_NODE$1 && (parent = process$2.domain)) parent.exit();
+    while (head) {
+      fn = head.fn;
+      head = head.next;
+      try {
+        fn();
+      } catch (error) {
+        if (head) notify$1();
+        else last = undefined;
+        throw error;
+      }
+    } last = undefined;
+    if (parent) parent.enter();
+  };
+
+  // Node.js
+  if (IS_NODE$1) {
+    notify$1 = function () {
+      process$2.nextTick(flush);
+    };
+  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
+  } else if (MutationObserver && !IS_IOS) {
+    toggle = true;
+    node = document.createTextNode('');
+    new MutationObserver(flush).observe(node, { characterData: true });
+    notify$1 = function () {
+      node.data = toggle = !toggle;
+    };
+  // environments with maybe non-completely correct, but existent Promise
+  } else if (Promise$1 && Promise$1.resolve) {
+    // Promise.resolve without an argument throws an error in LG WebOS 2
+    promise = Promise$1.resolve(undefined);
+    then = promise.then;
+    notify$1 = function () {
+      then.call(promise, flush);
+    };
+  // for other environments - macrotask based on:
+  // - setImmediate
+  // - MessageChannel
+  // - window.postMessag
+  // - onreadystatechange
+  // - setTimeout
+  } else {
+    notify$1 = function () {
+      // strange IE + webpack dev server bug - use .call(global)
+      macrotask.call(global$4, flush);
+    };
+  }
+}
+
+var microtask$1 = queueMicrotask || function (fn) {
+  var task = { fn: fn, next: undefined };
+  if (last) last.next = task;
+  if (!head) {
+    head = task;
+    notify$1();
+  } last = task;
+};
+
+var newPromiseCapability$2 = {};
+
+var aFunction$1 = aFunction$4;
+
+var PromiseCapability = function (C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = aFunction$1(resolve);
+  this.reject = aFunction$1(reject);
+};
+
+// 25.4.1.5 NewPromiseCapability(C)
+newPromiseCapability$2.f = function (C) {
+  return new PromiseCapability(C);
+};
+
+var anObject$2 = anObject$8;
+var isObject$3 = isObject$8;
+var newPromiseCapability$1 = newPromiseCapability$2;
+
+var promiseResolve$1 = function (C, x) {
+  anObject$2(C);
+  if (isObject$3(x) && x.constructor === C) return x;
+  var promiseCapability = newPromiseCapability$1.f(C);
+  var resolve = promiseCapability.resolve;
+  resolve(x);
+  return promiseCapability.promise;
+};
+
+var global$3 = global$h;
+
+var hostReportErrors$1 = function (a, b) {
+  var console = global$3.console;
+  if (console && console.error) {
+    arguments.length === 1 ? console.error(a) : console.error(a, b);
+  }
+};
+
+var perform$1 = function (exec) {
+  try {
+    return { error: false, value: exec() };
+  } catch (error) {
+    return { error: true, value: error };
+  }
+};
+
+var global$2 = global$h;
+var userAgent = engineUserAgent;
+
+var process$1 = global$2.process;
+var versions = process$1 && process$1.versions;
+var v8 = versions && versions.v8;
+var match, version;
+
+if (v8) {
+  match = v8.split('.');
+  version = match[0] + match[1];
+} else if (userAgent) {
+  match = userAgent.match(/Edge\/(\d+)/);
+  if (!match || match[1] >= 74) {
+    match = userAgent.match(/Chrome\/(\d+)/);
+    if (match) version = match[1];
+  }
+}
+
+var engineV8Version = version && +version;
+
+var $$3 = _export;
+var global$1 = global$h;
+var getBuiltIn = getBuiltIn$5;
+var NativePromise = nativePromiseConstructor;
+var redefine = redefine$3.exports;
+var redefineAll = redefineAll$1;
+var setToStringTag = setToStringTag$1;
+var setSpecies = setSpecies$1;
+var isObject$2 = isObject$8;
+var aFunction = aFunction$4;
+var anInstance = anInstance$1;
+var classof$2 = classofRaw$1;
+var inspectSource = inspectSource$3;
+var iterate = iterate$2.exports;
+var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
+var speciesConstructor = speciesConstructor$1;
+var task = task$1.set;
+var microtask = microtask$1;
+var promiseResolve = promiseResolve$1;
+var hostReportErrors = hostReportErrors$1;
+var newPromiseCapabilityModule = newPromiseCapability$2;
+var perform = perform$1;
+var InternalStateModule = internalState;
+var isForced = isForced_1;
+var wellKnownSymbol$4 = wellKnownSymbol$d;
+var V8_VERSION = engineV8Version;
+
+var SPECIES$1 = wellKnownSymbol$4('species');
+var PROMISE = 'Promise';
+var getInternalState = InternalStateModule.get;
+var setInternalState = InternalStateModule.set;
+var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+var PromiseConstructor = NativePromise;
+var TypeError$1 = global$1.TypeError;
+var document$1 = global$1.document;
+var process = global$1.process;
+var $fetch = getBuiltIn('fetch');
+var newPromiseCapability = newPromiseCapabilityModule.f;
+var newGenericPromiseCapability = newPromiseCapability;
+var IS_NODE = classof$2(process) == 'process';
+var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$1.dispatchEvent);
+var UNHANDLED_REJECTION = 'unhandledrejection';
+var REJECTION_HANDLED = 'rejectionhandled';
+var PENDING = 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+var HANDLED = 1;
+var UNHANDLED = 2;
+var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+
+var FORCED = isForced(PROMISE, function () {
+  var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);
+  if (!GLOBAL_CORE_JS_PROMISE) {
+    // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+    // We can't detect it synchronously, so just check versions
+    if (V8_VERSION === 66) return true;
+    // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+    if (!IS_NODE && typeof PromiseRejectionEvent != 'function') return true;
+  }
+  // We can't use @@species feature detection in V8 since it causes
+  // deoptimization and performance degradation
+  // https://github.com/zloirock/core-js/issues/679
+  if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor)) return false;
+  // Detect correctness of subclassing with @@species support
+  var promise = PromiseConstructor.resolve(1);
+  var FakePromise = function (exec) {
+    exec(function () { /* empty */ }, function () { /* empty */ });
+  };
+  var constructor = promise.constructor = {};
+  constructor[SPECIES$1] = FakePromise;
+  return !(promise.then(function () { /* empty */ }) instanceof FakePromise);
+});
+
+var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
+  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
+});
+
+// helpers
+var isThenable = function (it) {
+  var then;
+  return isObject$2(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+
+var notify = function (promise, state, isReject) {
+  if (state.notified) return;
+  state.notified = true;
+  var chain = state.reactions;
+  microtask(function () {
+    var value = state.value;
+    var ok = state.state == FULFILLED;
+    var index = 0;
+    // variable length - can't use forEach
+    while (chain.length > index) {
+      var reaction = chain[index++];
+      var handler = ok ? reaction.ok : reaction.fail;
+      var resolve = reaction.resolve;
+      var reject = reaction.reject;
+      var domain = reaction.domain;
+      var result, then, exited;
+      try {
+        if (handler) {
+          if (!ok) {
+            if (state.rejection === UNHANDLED) onHandleUnhandled(promise, state);
+            state.rejection = HANDLED;
+          }
+          if (handler === true) result = value;
+          else {
+            if (domain) domain.enter();
+            result = handler(value); // can throw
+            if (domain) {
+              domain.exit();
+              exited = true;
+            }
+          }
+          if (result === reaction.promise) {
+            reject(TypeError$1('Promise-chain cycle'));
+          } else if (then = isThenable(result)) {
+            then.call(result, resolve, reject);
+          } else resolve(result);
+        } else reject(value);
+      } catch (error) {
+        if (domain && !exited) domain.exit();
+        reject(error);
+      }
+    }
+    state.reactions = [];
+    state.notified = false;
+    if (isReject && !state.rejection) onUnhandled(promise, state);
+  });
+};
+
+var dispatchEvent = function (name, promise, reason) {
+  var event, handler;
+  if (DISPATCH_EVENT) {
+    event = document$1.createEvent('Event');
+    event.promise = promise;
+    event.reason = reason;
+    event.initEvent(name, false, true);
+    global$1.dispatchEvent(event);
+  } else event = { promise: promise, reason: reason };
+  if (handler = global$1['on' + name]) handler(event);
+  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
+};
+
+var onUnhandled = function (promise, state) {
+  task.call(global$1, function () {
+    var value = state.value;
+    var IS_UNHANDLED = isUnhandled(state);
+    var result;
+    if (IS_UNHANDLED) {
+      result = perform(function () {
+        if (IS_NODE) {
+          process.emit('unhandledRejection', value, promise);
+        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
+      });
+      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
+      if (result.error) throw result.value;
+    }
+  });
+};
+
+var isUnhandled = function (state) {
+  return state.rejection !== HANDLED && !state.parent;
+};
+
+var onHandleUnhandled = function (promise, state) {
+  task.call(global$1, function () {
+    if (IS_NODE) {
+      process.emit('rejectionHandled', promise);
+    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
+  });
+};
+
+var bind$1 = function (fn, promise, state, unwrap) {
+  return function (value) {
+    fn(promise, state, value, unwrap);
+  };
+};
+
+var internalReject = function (promise, state, value, unwrap) {
+  if (state.done) return;
+  state.done = true;
+  if (unwrap) state = unwrap;
+  state.value = value;
+  state.state = REJECTED;
+  notify(promise, state, true);
+};
+
+var internalResolve = function (promise, state, value, unwrap) {
+  if (state.done) return;
+  state.done = true;
+  if (unwrap) state = unwrap;
+  try {
+    if (promise === value) throw TypeError$1("Promise can't be resolved itself");
+    var then = isThenable(value);
+    if (then) {
+      microtask(function () {
+        var wrapper = { done: false };
+        try {
+          then.call(value,
+            bind$1(internalResolve, promise, wrapper, state),
+            bind$1(internalReject, promise, wrapper, state)
+          );
+        } catch (error) {
+          internalReject(promise, wrapper, error, state);
+        }
+      });
+    } else {
+      state.value = value;
+      state.state = FULFILLED;
+      notify(promise, state, false);
+    }
+  } catch (error) {
+    internalReject(promise, { done: false }, error, state);
+  }
+};
+
+// constructor polyfill
+if (FORCED) {
+  // 25.4.3.1 Promise(executor)
+  PromiseConstructor = function Promise(executor) {
+    anInstance(this, PromiseConstructor, PROMISE);
+    aFunction(executor);
+    Internal.call(this);
+    var state = getInternalState(this);
+    try {
+      executor(bind$1(internalResolve, this, state), bind$1(internalReject, this, state));
+    } catch (error) {
+      internalReject(this, state, error);
+    }
+  };
+  // eslint-disable-next-line no-unused-vars
+  Internal = function Promise(executor) {
+    setInternalState(this, {
+      type: PROMISE,
+      done: false,
+      notified: false,
+      parent: false,
+      reactions: [],
+      rejection: false,
+      state: PENDING,
+      value: undefined
+    });
+  };
+  Internal.prototype = redefineAll(PromiseConstructor.prototype, {
+    // `Promise.prototype.then` method
+    // https://tc39.github.io/ecma262/#sec-promise.prototype.then
+    then: function then(onFulfilled, onRejected) {
+      var state = getInternalPromiseState(this);
+      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
+      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+      reaction.fail = typeof onRejected == 'function' && onRejected;
+      reaction.domain = IS_NODE ? process.domain : undefined;
+      state.parent = true;
+      state.reactions.push(reaction);
+      if (state.state != PENDING) notify(this, state, false);
+      return reaction.promise;
+    },
+    // `Promise.prototype.catch` method
+    // https://tc39.github.io/ecma262/#sec-promise.prototype.catch
+    'catch': function (onRejected) {
+      return this.then(undefined, onRejected);
+    }
+  });
+  OwnPromiseCapability = function () {
+    var promise = new Internal();
+    var state = getInternalState(promise);
+    this.promise = promise;
+    this.resolve = bind$1(internalResolve, promise, state);
+    this.reject = bind$1(internalReject, promise, state);
+  };
+  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+    return C === PromiseConstructor || C === PromiseWrapper
+      ? new OwnPromiseCapability(C)
+      : newGenericPromiseCapability(C);
+  };
+
+  if (typeof NativePromise == 'function') {
+    nativeThen = NativePromise.prototype.then;
+
+    // wrap native Promise#then for native async functions
+    redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {
+      var that = this;
+      return new PromiseConstructor(function (resolve, reject) {
+        nativeThen.call(that, resolve, reject);
+      }).then(onFulfilled, onRejected);
+    // https://github.com/zloirock/core-js/issues/640
+    }, { unsafe: true });
+
+    // wrap fetch result
+    if (typeof $fetch == 'function') $$3({ global: true, enumerable: true, forced: true }, {
+      // eslint-disable-next-line no-unused-vars
+      fetch: function fetch(input /* , init */) {
+        return promiseResolve(PromiseConstructor, $fetch.apply(global$1, arguments));
+      }
+    });
+  }
+}
+
+$$3({ global: true, wrap: true, forced: FORCED }, {
+  Promise: PromiseConstructor
+});
+
+setToStringTag(PromiseConstructor, PROMISE, false);
+setSpecies(PROMISE);
+
+PromiseWrapper = getBuiltIn(PROMISE);
+
+// statics
+$$3({ target: PROMISE, stat: true, forced: FORCED }, {
+  // `Promise.reject` method
+  // https://tc39.github.io/ecma262/#sec-promise.reject
+  reject: function reject(r) {
+    var capability = newPromiseCapability(this);
+    capability.reject.call(undefined, r);
+    return capability.promise;
+  }
+});
+
+$$3({ target: PROMISE, stat: true, forced: FORCED }, {
+  // `Promise.resolve` method
+  // https://tc39.github.io/ecma262/#sec-promise.resolve
+  resolve: function resolve(x) {
+    return promiseResolve(this, x);
+  }
+});
+
+$$3({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
+  // `Promise.all` method
+  // https://tc39.github.io/ecma262/#sec-promise.all
+  all: function all(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var resolve = capability.resolve;
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aFunction(C.resolve);
+      var values = [];
+      var counter = 0;
+      var remaining = 1;
+      iterate(iterable, function (promise) {
+        var index = counter++;
+        var alreadyCalled = false;
+        values.push(undefined);
+        remaining++;
+        $promiseResolve.call(C, promise).then(function (value) {
+          if (alreadyCalled) return;
+          alreadyCalled = true;
+          values[index] = value;
+          --remaining || resolve(values);
+        }, reject);
+      });
+      --remaining || resolve(values);
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  },
+  // `Promise.race` method
+  // https://tc39.github.io/ecma262/#sec-promise.race
+  race: function race(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aFunction(C.resolve);
+      iterate(iterable, function (promise) {
+        $promiseResolve.call(C, promise).then(capability.resolve, reject);
+      });
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  }
+});
+
+const LocalStorageConstants = {
+  accessToken: 'access-token',
+  userData: 'user-data'
+};
+
+class HttpClient {
+  get client() {
+    return this._axiosInstance;
+  }
+  constructor(authenticationType, baseUrl) {
+    this._axiosInstance = axios__default["default"].create({
+      baseURL: baseUrl,
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8'
+      }
+    });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this._axiosInstance.interceptors.request.use(config => __awaiter(this, void 0, void 0, function* () {
+      const state$1 = state.store.getState();
+      if (state$1.user.loggedIn) {
+        return Object.assign(Object.assign({}, config), {
+          headers: Object.assign(Object.assign({}, config.headers), {
+            'Authorization': 'Bearer ' + localStorage.getItem(LocalStorageConstants.accessToken)
+          })
+        });
+      }
+      return config;
+    }));
+    this._axiosInstance.interceptors.response.use(response => response.data, error => {
+      if (error.response.status === 401) ;
+      return Promise.reject({
+        code: error.response.status,
+        message: error.response.data
+      });
+    });
+  }
+  static Instance() {
+    if (!HttpClient._instance) {
+      throw new Error('HttpClient is not initialized. Please call HttpClient.Init() before using HttpClient.Instance()');
+    }
+    return HttpClient._instance;
+  }
+  static Init(authenticationType, baseUrl, apiKeyOrAccessToken) {
+    if (HttpClient._instance) throw new Error('HttpClient is already initialized. Please call HttpClient.Instance() to get current instance.');
+    HttpClient._instance = new HttpClient(authenticationType, baseUrl);
+  }
+}
+
+function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";var r="undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function t(e){var t=e.replace(/-/g,"+").replace(/_/g,"/");switch(t.length%4){case 0:break;case 2:t+="==";break;case 3:t+="=";break;default:throw "Illegal base64url string!"}try{return function(e){return decodeURIComponent(r(e).replace(/(.)/g,(function(e,r){var t=r.charCodeAt(0).toString(16).toUpperCase();return t.length<2&&(t="0"+t),"%"+t})))}(t)}catch(e){return r(t)}}function n(e){this.message=e;}function o(e,r){if("string"!=typeof e)throw new n("Invalid token specified");var o=!0===(r=r||{}).header?0:1;try{return JSON.parse(t(e.split(".")[o]))}catch(e){throw new n("Invalid token specified: "+e.message)}}n.prototype=new Error,n.prototype.name="InvalidTokenError";
+
+class FluxoStateDispatcher {
+  static dispatchUserLogin(data) {
+    state.store.dispatch(state.userLogin(data));
+  }
+  static dispatchUserLogout() {
+    state.store.dispatch(state.userLogout());
+  }
+  static dispatchAutoLoginSucceded(userInfo) {
+    state.store.dispatch(state.autoLoginSucceded(userInfo));
+  }
+  static dispatchOpenSearchPanel() {
+    state.store.dispatch(state.openSearchPanel({}));
+  }
+  static dispatchCloseSearchPanel() {
+    state.store.dispatch(state.closeSearchPanel({}));
+  }
+  static dispatchSetUserIdle() {
+    state.store.dispatch(state.setUserIdle({}));
+  }
+  static dispatchUnsetUserIdle() {
+    state.store.dispatch(state.unsetUserIdle({}));
+  }
+  static dispatchOpenNavbar() {
+    state.store.dispatch(state.openNavbar({}));
+  }
+  static dispatchCloseNavbar() {
+    state.store.dispatch(state.closeNavbar({}));
+  }
+  static dispatchSetAppMenu(items) {
+    state.store.dispatch(state.setAppMenu(items));
+  }
+  static dispatchSetRouteRules(rules) {
+    state.store.dispatch(state.setRouteRules(rules));
+  }
+  static dispatchSetConfiguration(items) {
+    state.store.dispatch(state.setConfiguration(items));
+  }
+  static dispatchSetSysFeatures(items) {
+    state.store.dispatch(state.setSysFeatures(items));
+  }
+  static dispatchSetJitAppsFeatures(items) {
+    state.store.dispatch(state.setJitAppsFeatures(items));
+  }
+  static dispatchSetUserPermissions(items) {
+    state.store.dispatch(state.setUserPermissions(items));
+  }
+}
+
+class AuthService {
+  constructor() {
+    RefreshTokenManager.Init(this.refreshToken, this.logout);
+  }
+  setup() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.tryAutoLogin();
+    });
+  }
+  tryAutoLogin() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const accessToken = localStorage.getItem(LocalStorageConstants.accessToken);
+      if (accessToken) {
+        const decoded = o(accessToken);
+        if (!decoded) {
+          this.logout();
+          return;
+        }
+        if (decoded.exp <= new Date().getTime() / 1000) {
+          yield this.refreshToken();
+        } else {
+          // Avvio il timeout indicando il tempo di attesa come scadenza token - 30 secondi.
+          // pertanto, 30 secondi prima della scadenza del token, Fluxo richiederà un nuovo token grazie al refresh token.
+          RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime() - 30000);
+        }
+        FluxoStateDispatcher.dispatchAutoLoginSucceded(localStorage.getItem(LocalStorageConstants.userData));
+      }
+    });
+  }
+  login(username, password) {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const data = yield HttpClient.Instance().client.post('/identity/authenticate', {
+          username,
+          password
+        }, {
+          withCredentials: true
+        });
+        localStorage.setItem(LocalStorageConstants.accessToken, data.token);
+        localStorage.setItem(LocalStorageConstants.userData, JSON.stringify(data.userData));
+        RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime() - 60);
+        FluxoStateDispatcher.dispatchUserLogin({
+          data
+        });
+      } catch (err) {
+        FluxoStateDispatcher.dispatchUserLogin(null);
+      }
+    });
+  }
+  logout() {
+    RefreshTokenManager.Instance.stop();
+    localStorage.removeItem(LocalStorageConstants.accessToken);
+    localStorage.removeItem(LocalStorageConstants.userData);
+    FluxoStateDispatcher.dispatchUserLogout();
+  }
+  refreshToken() {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const data = yield HttpClient.Instance().client.post('/identity/refresh-token', {}, {
+          withCredentials: true
+        });
+        localStorage.setItem(LocalStorageConstants.accessToken, data.token);
+        localStorage.setItem(LocalStorageConstants.userData, JSON.stringify(data.userData));
+        RefreshTokenManager.Instance.stop();
+        RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime() - 10000);
+      } catch (err) {
+        localStorage.removeItem(LocalStorageConstants.accessToken);
+        localStorage.removeItem(LocalStorageConstants.userData);
+        this.logout();
+      }
+    });
+  }
+  static getJwtTokenRemainingLifetime() {
+    const token = localStorage.getItem(LocalStorageConstants.accessToken);
+    if (!token) {
+      throw new Error('Called getJwtTokenRemainingLifetime but no access token found');
+    }
+    const decoded = o(token);
+    const exp = +decoded.exp;
+    const dateNow = new Date(Date.now()).getTime();
+    const diff = exp * 1000 - dateNow;
+    return diff <= 0 ? 0 : diff;
+  }
+}
+class RefreshTokenManager {
+  constructor(action, onErrorCallback) {
+    this.event = new Event('build');
+    this._refreshTokenInterval = null;
+    this._actionOnTimeout = action;
+    this._onErrorCallback = onErrorCallback;
+  }
+  static Init(actionOnTimeout, onErrorCallback) {
+    this._instance = new this(actionOnTimeout, onErrorCallback);
+  }
+  static get Instance() {
+    if (!this._instance) throw new Error('RefreshTokenManager not initialized');
+    return this._instance;
+  }
+  start(timeoutMs) {
+    console.info('   - start refresh token:' + timeoutMs + 'ms');
+    if (this._actionOnTimeout === undefined) throw new Error('RefreshTokenManager not initialized');
+    this._refreshTokenInterval = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+      try {
+        yield this._actionOnTimeout();
+      } catch (err) {
+        this._onErrorCallback();
+      }
+    }), timeoutMs);
+  }
+  stop() {
+    console.info('   - stop refresh token');
+    clearInterval(this._refreshTokenInterval);
+  }
+}
+
+class ConfigurationService {
+  getInitialConfiguration() {
+    return HttpClient.Instance().client.get('client/initial');
+  }
+  getClientUi() {
+    return HttpClient.Instance().client.get('client/ui');
+  }
+  updateClientUi(clientUI) {
+    return HttpClient.Instance().client.post('client/ui', clientUI);
+  }
+  getSystemFeatures() {
+    return HttpClient.Instance().client.get('features/web');
+  }
+  saveAppMenu(webMenuId, menu) {
+    return HttpClient.Instance().client.post(`client/menu/${webMenuId}/webapp`, menu);
+  }
+  createAppMenu(menu) {
+    return HttpClient.Instance().client.post('client/menu/webapp', menu);
+  }
+  getAppMenuList() {
+    return HttpClient.Instance().client.get('webmenu?includes=DomainRole,User');
+  }
+  getAppMenu(webMenuId) {
+    return HttpClient.Instance().client.get(`client/menu/${webMenuId}/webapp`);
+  }
+  getMenuItemPermissions(domainRoleId) {
+    return HttpClient.Instance().client.get(`webmenuitem/${domainRoleId}/permissions`);
+  }
+  addMenuItemPermission(domainRoleId, permissionId) {
+    return HttpClient.Instance().client.post(`webmenuitem/${domainRoleId}/permissions`, {
+      domainRoleId: domainRoleId,
+      permissionId: permissionId
+    });
+  }
+  removeMenuItemPermission(domainRoleId, permissionId) {
+    return HttpClient.Instance().client.delete(`webmenuitem/${domainRoleId}/permissions/${permissionId}`);
+  }
+}
+
+var DESCRIPTORS$1 = descriptors;
+var definePropertyModule$1 = objectDefineProperty;
+var anObject$1 = anObject$8;
+var objectKeys = objectKeys$2;
+
+// `Object.defineProperties` method
+// https://tc39.github.io/ecma262/#sec-object.defineproperties
+var objectDefineProperties = DESCRIPTORS$1 ? Object.defineProperties : function defineProperties(O, Properties) {
+  anObject$1(O);
+  var keys = objectKeys(Properties);
+  var length = keys.length;
+  var index = 0;
+  var key;
+  while (length > index) definePropertyModule$1.f(O, key = keys[index++], Properties[key]);
+  return O;
+};
+
+var anObject = anObject$8;
+var defineProperties = objectDefineProperties;
+var enumBugKeys = enumBugKeys$3;
+var hiddenKeys = hiddenKeys$4;
+var html = html$2;
+var documentCreateElement = documentCreateElement$1;
+var sharedKey = sharedKey$2;
+
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO = sharedKey('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('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 {
+    /* global ActiveXObject */
+    activeXDocument = document.domain && new ActiveXObject('htmlfile');
+  } catch (error) { /* ignore */ }
+  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
+  var length = enumBugKeys.length;
+  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+  return NullProtoObject();
+};
+
+hiddenKeys[IE_PROTO] = true;
+
+// `Object.create` method
+// https://tc39.github.io/ecma262/#sec-object.create
+var objectCreate = Object.create || function create(O, Properties) {
+  var result;
+  if (O !== null) {
+    EmptyConstructor[PROTOTYPE] = anObject(O);
+    result = new EmptyConstructor();
+    EmptyConstructor[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO] = O;
+  } else result = NullProtoObject();
+  return Properties === undefined ? result : defineProperties(result, Properties);
+};
+
+var wellKnownSymbol$3 = wellKnownSymbol$d;
+var create = objectCreate;
+var definePropertyModule = objectDefineProperty;
+
+var UNSCOPABLES = wellKnownSymbol$3('unscopables');
+var ArrayPrototype = Array.prototype;
+
+// Array.prototype[@@unscopables]
+// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype[UNSCOPABLES] == undefined) {
+  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
+    configurable: true,
+    value: create(null)
+  });
+}
+
+// add a key to Array.prototype[@@unscopables]
+var addToUnscopables$2 = function (key) {
+  ArrayPrototype[UNSCOPABLES][key] = true;
+};
+
+var DESCRIPTORS = descriptors;
+var fails = fails$8;
+var has = has$8;
+
+var defineProperty = Object.defineProperty;
+var cache = {};
+
+var thrower = function (it) { throw it; };
+
+var arrayMethodUsesToLength$1 = function (METHOD_NAME, options) {
+  if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];
+  if (!options) options = {};
+  var method = [][METHOD_NAME];
+  var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;
+  var argument0 = has(options, 0) ? options[0] : thrower;
+  var argument1 = has(options, 1) ? options[1] : undefined;
+
+  return cache[METHOD_NAME] = !!method && !fails(function () {
+    if (ACCESSORS && !DESCRIPTORS) return true;
+    var O = { length: -1 };
+
+    if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower });
+    else O[1] = 1;
+
+    method.call(O, argument0, argument1);
+  });
+};
+
+var $$2 = _export;
+var $includes = arrayIncludes.includes;
+var addToUnscopables$1 = addToUnscopables$2;
+var arrayMethodUsesToLength = arrayMethodUsesToLength$1;
+
+var USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', { ACCESSORS: true, 1: 0 });
+
+// `Array.prototype.includes` method
+// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+$$2({ target: 'Array', proto: true, forced: !USES_TO_LENGTH }, {
+  includes: function includes(el /* , fromIndex = 0 */) {
+    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables$1('includes');
+
+var isObject$1 = isObject$8;
+var classof$1 = classofRaw$1;
+var wellKnownSymbol$2 = wellKnownSymbol$d;
+
+var MATCH$1 = wellKnownSymbol$2('match');
+
+// `IsRegExp` abstract operation
+// https://tc39.github.io/ecma262/#sec-isregexp
+var isRegexp = function (it) {
+  var isRegExp;
+  return isObject$1(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) == 'RegExp');
+};
+
+var isRegExp = isRegexp;
+
+var notARegexp = function (it) {
+  if (isRegExp(it)) {
+    throw TypeError("The method doesn't accept regular expressions");
+  } return it;
+};
+
+var wellKnownSymbol$1 = wellKnownSymbol$d;
+
+var MATCH = wellKnownSymbol$1('match');
+
+var correctIsRegexpLogic = function (METHOD_NAME) {
+  var regexp = /./;
+  try {
+    '/./'[METHOD_NAME](regexp);
+  } catch (e) {
+    try {
+      regexp[MATCH] = false;
+      return '/./'[METHOD_NAME](regexp);
+    } catch (f) { /* empty */ }
+  } return false;
+};
+
+var $$1 = _export;
+var notARegExp = notARegexp;
+var requireObjectCoercible = requireObjectCoercible$3;
+var correctIsRegExpLogic = correctIsRegexpLogic;
+
+// `String.prototype.includes` method
+// https://tc39.github.io/ecma262/#sec-string.prototype.includes
+$$1({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {
+  includes: function includes(searchString /* , position = 0 */) {
+    return !!~String(requireObjectCoercible(this))
+      .indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+class UserService {
+  constructor() {}
+  currentUserHasPermissions(requiredPermissions, strategy = 'all') {
+    const userPermissions = state.store.getState().user.userPermissions;
+    if (!userPermissions) {
+      return false;
+    }
+    if (requiredPermissions.length === 0) {
+      return true;
+    }
+    const checkerAll = (arr, target) => target.every(v => arr.includes(v));
+    const checkerAny = (arr, target) => target.some(v => arr.includes(v));
+    let result;
+    if (strategy === 'all') {
+      result = checkerAll(userPermissions, requiredPermissions);
+    } else {
+      result = checkerAny(userPermissions, requiredPermissions);
+    }
+    if (result) {
+      return true;
+    }
+    return false;
+  }
+  getAllUsers() {
+    return HttpClient.Instance().client.get(`/identity/user`);
+  }
+  createUser(user) {
+    return HttpClient.Instance().client.post(`/identity/user`, user);
+  }
+  updateUser(userId, user) {
+    return HttpClient.Instance().client.put(`/identity/user/${userId}`, user);
+  }
+  deleteUser(userId) {
+    return HttpClient.Instance().client.delete(`/identity/user/${userId}`);
+  }
+  confirmEmail(user) {
+    return HttpClient.Instance().client.post(`/identity/confirm/email`, user);
+  }
+  changePassword(changePassword) {
+    return HttpClient.Instance().client.post(`/identity/changepassword`, changePassword);
+  }
+  forgotPassword(email) {
+    return HttpClient.Instance().client.post(`/identity/forgotpassword/require/${encodeURI(email)}`, null);
+  }
+  forgotPasswordConfirm(forgotPassword) {
+    return HttpClient.Instance().client.post(`/identity/forgotpassword/confirm`, forgotPassword);
+  }
+  disableUserLogin(userId) {
+    return HttpClient.Instance().client.post(`/disableuser/${userId}`);
+  }
+  enableUserLogin(userId) {
+    return HttpClient.Instance().client.post(`/enableuser/${userId}`);
+  }
+}
+
+class BaseCommonService {
+  get baseApiPath() {
+    return this._baseApiPath;
+  }
+  constructor(baseApiPath) {
+    this._baseApiPath = baseApiPath;
+  }
+  find(take, skip, filters, include, namedFilters, orderBy) {
+    let url = `/${this._baseApiPath}?take=${take}&skip=${skip}${filters ? `&filter=${encodeURIComponent(filters)}` : ''}${include ? `&includes=${encodeURIComponent(include)}` : ''}${orderBy ? `&orderBy=${encodeURIComponent(orderBy)}` : ''}`;
+    if (namedFilters) {
+      namedFilters.forEach(filter => {
+        url += `&${filter.key}=${filter.value}`;
+      });
+    }
+    return HttpClient.Instance().client.get(url);
+  }
+  create(entity) {
+    return HttpClient.Instance().client.post(`/${this._baseApiPath}`, entity);
+  }
+  update(id, entity) {
+    return HttpClient.Instance().client.put(`/${this._baseApiPath}/${id}`, entity);
+  }
+  delete(entityId) {
+    return HttpClient.Instance().client.delete(`/${this._baseApiPath}/${entityId}`);
+  }
+  get(id, include) {
+    return HttpClient.Instance().client.get(`/${this._baseApiPath}/${id}${include ? `?includes=${encodeURIComponent(include)}` : ''}`);
+  }
+}
+
+class DomainRoleService extends BaseCommonService {
+  constructor() {
+    super('domainroles');
+  }
+  getPermissions(domainRoleId) {
+    return HttpClient.Instance().client.get(`domainroles/${domainRoleId}/permissions`);
+  }
+  addPermission(domainRoleId, permissionId) {
+    return HttpClient.Instance().client.post(`domainroles/${domainRoleId}/permissions`, {
+      domainRoleId: domainRoleId,
+      permissionId: permissionId
+    });
+  }
+  removePermission(domainRoleId, permissionId) {
+    return HttpClient.Instance().client.delete(`domainroles/${domainRoleId}/permissions/${permissionId}`);
+  }
+}
+
+class ApiKeyService {
+  constructor() {}
+  getApiKeys() {
+    return HttpClient.Instance().client.get(`/identity/apikey`);
+  }
+  create(apiKey) {
+    return HttpClient.Instance().client.post(`/identity/apikey`, apiKey);
+  }
+  delete(apiKeyId) {
+    return HttpClient.Instance().client.delete(`/identity/apikey/${apiKeyId}`);
+  }
+  enable(apiKeyId) {
+    return HttpClient.Instance().client.get(`/identity/apikey/${apiKeyId}/enable`);
+  }
+  disable(apiKeyId) {
+    return HttpClient.Instance().client.get(`/identity/apikey/${apiKeyId}/disable`);
+  }
+}
+
+class PermissionService {
+  getPermissionScopes() {
+    return HttpClient.Instance().client.get('identity/permissions/scopes');
+  }
+  getPermissionsInScope(scope, packageName, namespace) {
+    return HttpClient.Instance().client.get(`identity/permissions/${scope}/${packageName}/${namespace}`);
+  }
+  createPermissionScope(data) {
+    return HttpClient.Instance().client.post(`identity/permissions/scopes`, data);
+  }
+  deletePermissionScope(scope, packageName, namespace) {
+    return HttpClient.Instance().client.delete(`identity/permissions/scopes/${scope}/${packageName}/${namespace}`);
+  }
+  installPermissions(data) {
+    return HttpClient.Instance().client.post('apps/permissions/install', data);
+  }
+  createCustomPermission(data) {
+    return HttpClient.Instance().client.post('identity/permissions/custom', data);
+  }
+  deleteCustomPermission(permissionId) {
+    return HttpClient.Instance().client.delete(`identity/permissions/custom/${permissionId}`);
+  }
+}
+
+class RouteRuleService extends BaseCommonService {
+  constructor() {
+    super('route-rule');
+  }
+  getRouteRulesForScope(scope, packageName) {
+    return HttpClient.Instance().client.get(`route-rule?scope=${scope}&packageName=${packageName}`);
+  }
+  getPermissions(routeRuleId) {
+    return HttpClient.Instance().client.get(`route-rule/${routeRuleId}/permissions`);
+  }
+  addPermission(routeRuleId, permissionId) {
+    return HttpClient.Instance().client.post(`route-rule/${routeRuleId}/permissions`, {
+      domainRoleId: routeRuleId,
+      permissionId: permissionId
+    });
+  }
+  removePermission(routeRuleId, permissionId) {
+    return HttpClient.Instance().client.delete(`route-rule/${routeRuleId}/permissions/${permissionId}`);
+  }
+}
+
+class SecurityFacade {
+  constructor() {
+    this._userService = new UserService();
+    this._apiKeyService = new ApiKeyService();
+    this._domainRoleService = new DomainRoleService();
+    this._permissionService = new PermissionService();
+    this._routeRuleService = new RouteRuleService();
+  }
+  get user() {
+    return this._userService;
+  }
+  get permission() {
+    return this._permissionService;
+  }
+  get routeRule() {
+    return this._routeRuleService;
+  }
+  get apiKey() {
+    return this._apiKeyService;
+  }
+  get domainRole() {
+    return this._domainRoleService;
+  }
+}
+
+class DocumentationService {
+  constructor() {
+    this.getTypeNameFromFullName = typeFullName => {
+      var _a;
+      const tNameSplitted = (_a = typeFullName.split(',')[0]) === null || _a === void 0 ? void 0 : _a.split('.');
+      if (tNameSplitted) {
+        return tNameSplitted[tNameSplitted.length - 1];
+      }
+      return 'ERROR';
+    };
+  }
+  getRestApiDocumentation() {
+    return HttpClient.Instance().client.get('korebi/documentation');
+  }
+  getTypeSchema(typeFullyQualifiedName) {
+    return HttpClient.Instance().client.get(`korebi/openapischema?types=${encodeURIComponent(typeFullyQualifiedName)}`);
+  }
+  searchType(typeName) {
+    return HttpClient.Instance().client.get(`korebi/searchtypes?type=${encodeURIComponent(typeName)}`);
+  }
+}
+
+class IntellisenseService {
+  complete(payload) {
+    return HttpClient.Instance().client.post('korebi/intellisense/complete', payload);
+  }
+  signature(payload) {
+    return HttpClient.Instance().client.post('korebi/intellisense/signature', payload);
+  }
+  hover(payload) {
+    return HttpClient.Instance().client.post('korebi/intellisense/hover', payload);
+  }
+  codeCheck(payload) {
+    return HttpClient.Instance().client.post('korebi/intellisense/codecheck', payload);
+  }
+}
+
+class AppServiceService {
+  getAppService() {
+    return HttpClient.Instance().client.get('korebi/apiservices');
+  }
+}
+
+class DynamicConfigurationService {
+  getDynamicConfiguration() {
+    return HttpClient.Instance().client.get('korebi/dynamicconfiguration');
+  }
+  simulateDynamicConfiguration(tenantJsonConfiguration) {
+    return HttpClient.Instance().client.post('korebi/simulatedeploy', tenantJsonConfiguration);
+  }
+  deployDynamicConfiguration(tenantJsonConfiguration) {
+    return HttpClient.Instance().client.post('korebi/deploy', tenantJsonConfiguration);
+  }
+}
+
+class KorebiFacade {
+  constructor() {
+    this._documentationService = new DocumentationService();
+    this._appServiceService = new AppServiceService();
+    this._dynamicConfigurationService = new DynamicConfigurationService();
+    this._intellisenseService = new IntellisenseService();
+  }
+  get documentation() {
+    return this._documentationService;
+  }
+  get appService() {
+    return this._appServiceService;
+  }
+  get dynamicConfiguration() {
+    return this._dynamicConfigurationService;
+  }
+  get intellisense() {
+    return this._intellisenseService;
+  }
+}
+
+class AppService {
+  getApps(onlyDeployed) {
+    const url = onlyDeployed ? 'apps?onlyDeployed=true' : 'apps';
+    return HttpClient.Instance().client.get(url);
+  }
+  activateApp(appId) {
+    return HttpClient.Instance().client.post(`apps/${appId}/activate`, {});
+  }
+  deactivateApp(appId) {
+    return HttpClient.Instance().client.post(`apps/${appId}/deactivate`, {});
+  }
+  installApp(data) {
+    return HttpClient.Instance().client.post(`apps/install`, data, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  }
+  upgradeApp(appId, data) {
+    return HttpClient.Instance().client.post(`apps/${appId}/upgrade`, data, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  }
+  uninstallApp(appId) {
+    return HttpClient.Instance().client.delete(`apps/${appId}/uninstall`);
+  }
+  installEmbeddedModule(data) {
+    return HttpClient.Instance().client.post(`apps/install/embedded`, data);
+  }
+}
+
+exports.AppType = void 0;
+(function (AppType) {
+  AppType[AppType["Frontend"] = 0] = "Frontend";
+  AppType[AppType["Backend"] = 1] = "Backend";
+})(exports.AppType || (exports.AppType = {}));
+
+exports.AppState = void 0;
+(function (AppState) {
+  AppState[AppState["Active"] = 0] = "Active";
+  AppState[AppState["Inactive"] = 1] = "Inactive";
+})(exports.AppState || (exports.AppState = {}));
+
+var classof = classofRaw$1;
+
+// `IsArray` abstract operation
+// https://tc39.github.io/ecma262/#sec-isarray
+var isArray$2 = Array.isArray || function isArray(arg) {
+  return classof(arg) == 'Array';
+};
+
+var isArray$1 = isArray$2;
+var toLength$1 = toLength$4;
+var bind = functionBindContext;
+
+// `FlattenIntoArray` abstract operation
+// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
+var flattenIntoArray$1 = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
+  var targetIndex = start;
+  var sourceIndex = 0;
+  var mapFn = mapper ? bind(mapper, thisArg, 3) : false;
+  var element;
+
+  while (sourceIndex < sourceLen) {
+    if (sourceIndex in source) {
+      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
+
+      if (depth > 0 && isArray$1(element)) {
+        targetIndex = flattenIntoArray$1(target, original, element, toLength$1(element.length), targetIndex, depth - 1) - 1;
+      } else {
+        if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length');
+        target[targetIndex] = element;
+      }
+
+      targetIndex++;
+    }
+    sourceIndex++;
+  }
+  return targetIndex;
+};
+
+var flattenIntoArray_1 = flattenIntoArray$1;
+
+var isObject = isObject$8;
+var isArray = isArray$2;
+var wellKnownSymbol = wellKnownSymbol$d;
+
+var SPECIES = wellKnownSymbol('species');
+
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.github.io/ecma262/#sec-arrayspeciescreate
+var arraySpeciesCreate$1 = function (originalArray, length) {
+  var C;
+  if (isArray(originalArray)) {
+    C = originalArray.constructor;
+    // cross-realm fallback
+    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
+    else if (isObject(C)) {
+      C = C[SPECIES];
+      if (C === null) C = undefined;
+    }
+  } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
+};
+
+var $ = _export;
+var flattenIntoArray = flattenIntoArray_1;
+var toObject = toObject$2;
+var toLength = toLength$4;
+var toInteger = toInteger$3;
+var arraySpeciesCreate = arraySpeciesCreate$1;
+
+// `Array.prototype.flat` method
+// https://github.com/tc39/proposal-flatMap
+$({ target: 'Array', proto: true }, {
+  flat: function flat(/* depthArg = 1 */) {
+    var depthArg = arguments.length ? arguments[0] : undefined;
+    var O = toObject(this);
+    var sourceLen = toLength(O.length);
+    var A = arraySpeciesCreate(O, 0);
+    A.length = flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));
+    return A;
+  }
+});
+
+// this method was added to unscopables after implementation
+// in popular engines, so it's moved to a separate module
+var addToUnscopables = addToUnscopables$2;
+
+addToUnscopables('flat');
+
+class EmbeddedModule {
+  get name() {
+    return this._name;
+  }
+  get description() {
+    return this._description;
+  }
+  get author() {
+    return this._author;
+  }
+  get version() {
+    return this._version;
+  }
+  get scope() {
+    return this._scope;
+  }
+  get navigation() {
+    return this._navigation;
+  }
+  constructor(name, description, author, version, scope) {
+    this._navigation = [];
+    this._name = name;
+    this._description = description;
+    this._author = author;
+    this._version = version;
+    this._scope = scope;
+  }
+  attachNavigation(navigationConfig) {
+    this._navigation.push(navigationConfig);
+  }
+  getRouteObject(routes = undefined) {
+    const r = routes !== null && routes !== void 0 ? routes : this._navigation.map(a => a.routes).map(a => a).flat();
+    if (!r || r.length === 0) return [];
+    const routeObject = [];
+    r.map(route => {
+      if (route.route) {
+        let path = route.route;
+        if (route.route === '/') {
+          path = '';
+        }
+        if (route.route === "*") {
+          path = '*';
+        }
+        routeObject.push({
+          path: path,
+          index: route.route === '/' ? undefined : false,
+          element: route.component,
+          children: route.routes && route.routes.length > 0 ? this.getRouteObject(route.routes) : []
+        });
+      }
+    });
+    return routeObject;
+  }
+  getEmbeddedModule() {
+    const conf = {
+      name: this._name,
+      description: this._description,
+      author: this._author,
+      version: this._version,
+      scope: this._scope,
+      menu: this._navigation.map(a => a.menu)
+    };
+    return conf;
+  }
+}
+
+class ReportingService {
+  getReportsList(scopeFilter) {
+    return HttpClient.Instance().client.get(scopeFilter ? `reports/types/list?scopeFilter=${scopeFilter}` : 'reports/types/list');
+  }
+  createReport(command) {
+    return HttpClient.Instance().client.post('reports', command);
+  }
+  getReportById(id) {
+    return HttpClient.Instance().client.get(`reports/${id}`);
+  }
+  deleteReport(id) {
+    return HttpClient.Instance().client.delete(`reports/${id}`);
+  }
+  getParametersSchema(fullScope) {
+    return HttpClient.Instance().client.get(`reports/params/schema/${fullScope}`);
+  }
+  print(command) {
+    return HttpClient.Instance().client.post('reports/print', command);
+  }
+}
+
+exports.PrinterType = void 0;
+(function (PrinterType) {
+  PrinterType[PrinterType["Managed"] = 0] = "Managed";
+  PrinterType[PrinterType["Unmanaged"] = 1] = "Unmanaged";
+})(exports.PrinterType || (exports.PrinterType = {}));
+
+exports.PrintServerType = void 0;
+(function (PrintServerType) {
+  PrintServerType[PrintServerType["Direct"] = 0] = "Direct";
+  PrintServerType[PrintServerType["Remote"] = 1] = "Remote";
+})(exports.PrintServerType || (exports.PrintServerType = {}));
+
+exports.PrinterManufacturer = void 0;
+(function (PrinterManufacturer) {
+  PrinterManufacturer[PrinterManufacturer["Zebra"] = 0] = "Zebra";
+})(exports.PrinterManufacturer || (exports.PrinterManufacturer = {}));
+
+exports.PrintServerManagedType = void 0;
+(function (PrintServerManagedType) {
+  PrintServerManagedType[PrintServerManagedType["Ipp"] = 0] = "Ipp";
+  PrintServerManagedType[PrintServerManagedType["Windows"] = 1] = "Windows";
+})(exports.PrintServerManagedType || (exports.PrintServerManagedType = {}));
+
+class PrintingService {
+  GetPrintServerList() {
+    return HttpClient.Instance().client.get(`print-server?includes=Printers`);
+  }
+  GetPrintServer(printServerId) {
+    return HttpClient.Instance().client.get(`print-server/${printServerId}`);
+  }
+  UpdatePrintServer(printServerId, command) {
+    return HttpClient.Instance().client.put(`print-server/${printServerId}`, command);
+  }
+  GetPrintServerPrinters(printServerId) {
+    return HttpClient.Instance().client.get(`print-server/${printServerId}/printers`);
+  }
+  CreatePrintServer(command) {
+    return HttpClient.Instance().client.post(`print-server`, command);
+  }
+  AddPrinter(printServerId, command) {
+    return HttpClient.Instance().client.post(`print-server/${printServerId}/virtual-printers`, command);
+  }
+}
+
+exports.WorkflowActionInputType = void 0;
+(function (WorkflowActionInputType) {
+  WorkflowActionInputType[WorkflowActionInputType["none"] = 0] = "none";
+  WorkflowActionInputType[WorkflowActionInputType["manual"] = 1] = "manual";
+  WorkflowActionInputType[WorkflowActionInputType["dynamic"] = 2] = "dynamic";
+  WorkflowActionInputType[WorkflowActionInputType["expression"] = 3] = "expression";
+})(exports.WorkflowActionInputType || (exports.WorkflowActionInputType = {}));
+
+class WorkflowService {
+  getActionsDefinition() {
+    return HttpClient.Instance().client.get('workflow/designer/actions');
+  }
+  getTriggersDefinition() {
+    return HttpClient.Instance().client.get('workflow/designer/triggers');
+  }
+  test(workflow) {
+    return HttpClient.Instance().client.post('workflow/convert', workflow);
+  }
+}
+
+class FluxoClientBase {
+  constructor() {
+    this._authenticationType = null;
+    this._securityFacade = null;
+    this._authService = null;
+    this._configurationService = null;
+    this._korebiFacade = null;
+    this._appsService = null;
+    this._reportingService = null;
+    this._printingService = null;
+    this._workflowService = null;
+    this._config = null;
+    this._modules = [];
+    this.getBearerToken = () => {
+      const jwtToken = localStorage.getItem('access-token');
+      return jwtToken !== null && jwtToken !== void 0 ? jwtToken : '';
+    };
+  }
+  get modules() {
+    return this._modules;
+  }
+  static get HttpClient() {
+    return HttpClient.Instance();
+  }
+  register(module) {
+    this._modules.push(module);
+  }
+  /**
+   * Creates an instance of FluxoClient
+   */
+  setup(config, setState) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this._config = config;
+      console.info('-*-*-*- FluxoClient setup started -*-*-*-');
+      this._authenticationType = config.authenticationType;
+      if (this._authenticationType === state.AuthenticationType.ApiKey && !config.apiKey) {
+        throw new Error('ApiKey is required in ApiKey Authentication mode.');
+      }
+      console.info('1) Set authentication type: ' + this._authenticationType);
+      const apiKeyOrToken = config.authenticationType === state.AuthenticationType.ApiKey ? config.apiKey : this.getBearerToken();
+      console.info('2) Initialize HTTPClient setup');
+      HttpClient.Init(this._authenticationType, config.fluxoInstanceUrl, apiKeyOrToken);
+      console.info('3) HTTPClient initialized');
+      console.info('4) Initializa auth service');
+      this._authService = new AuthService();
+      yield this._authService.setup();
+      console.info('5) Auth service initialized');
+      console.info('6) Initialize sub services');
+      /** other services **/
+      this.AddSetupConfiguration(config);
+      this._configurationService = new ConfigurationService();
+      this._korebiFacade = new KorebiFacade();
+      this._appsService = new AppService();
+      this._securityFacade = new SecurityFacade();
+      this._reportingService = new ReportingService();
+      this._printingService = new PrintingService();
+      this._workflowService = new WorkflowService();
+      console.info('7) Sub services initialized');
+      if (setState) state.store.dispatch(state.setFluxoClientConfiguration(config));
+      console.info('-*-*-*- FluxoClient setup finished -*-*-*-');
+    });
+  }
+  get clientConfig() {
+    if (!this._config) throw new Error('FluxoClient is not initialized. Please call FluxoClient.Init() before using FluxoClient.Instance()');
+    return this._config;
+  }
+  get security() {
+    return this._securityFacade;
+  }
+  get auth() {
+    return this._authService;
+  }
+  get configuration() {
+    return this._configurationService;
+  }
+  get korebi() {
+    return this._korebiFacade;
+  }
+  get apps() {
+    return this._appsService;
+  }
+  get reporting() {
+    return this._reportingService;
+  }
+  get printing() {
+    return this._printingService;
+  }
+  get workflow() {
+    return this._workflowService;
+  }
+}
+
+class FluxoClientSys {
+  constructor() {}
+  static Init(instance) {
+    if (FluxoClientSys._initialized) throw new Error('FluxoClientBaseFactory is already initialized. Please call FluxoClientBaseFactory.Instance() to get current instance.');
+    FluxoClientSys._instance = instance;
+    FluxoClientSys._initialized = true;
+  }
+  static get Instance() {
+    if (!FluxoClientSys._initialized) {
+      throw new Error('FluxoClientBaseFactory is not initialized. Please call FluxoClientBaseFactory.Init() before using FluxoClientBaseFactory.Instance()');
+    }
+    return FluxoClientSys._instance;
+  }
+}
+FluxoClientSys._initialized = false;
+FluxoClientSys._instance = null;
+
+exports.AppMenuContextType = void 0;
+(function (AppMenuContextType) {
+  AppMenuContextType[AppMenuContextType["Default"] = 0] = "Default";
+  AppMenuContextType[AppMenuContextType["DomainRole"] = 1] = "DomainRole";
+  AppMenuContextType[AppMenuContextType["User"] = 2] = "User";
+})(exports.AppMenuContextType || (exports.AppMenuContextType = {}));
+
+class ServerFilterHelper {
+  static getFilterString(filter, globalSearchQuery, globalSearchQueryFields, globalQueryOperator = 'or') {
+    let filtersString = filter ? filter : '';
+    const globalSearchFilterArray = [];
+    if (globalSearchQuery && globalSearchQueryFields) {
+      let gFilter = '';
+      globalSearchQueryFields.forEach(field => {
+        if (field.fieldType === 'string') gFilter = `(obj.${field.fieldName}.ToLower().Contains("${globalSearchQuery}".ToLower()))`;else gFilter = `(obj.${field.fieldName} == ${globalSearchQuery})`;
+        globalSearchFilterArray.push(gFilter);
+      });
+    }
+    if (globalSearchFilterArray.length > 0) {
+      if (filtersString !== '') filtersString = filtersString + ` ${globalQueryOperator} ` + globalSearchFilterArray.join(" or ");else filtersString = globalSearchFilterArray.join(" or ");
+    }
+    return filtersString;
+  }
+}
+
+exports.ApiKeyService = ApiKeyService;
+exports.AppService = AppService;
+exports.AppServiceService = AppServiceService;
+exports.BaseCommonService = BaseCommonService;
+exports.DocumentationService = DocumentationService;
+exports.DomainRoleService = DomainRoleService;
+exports.DynamicConfigurationService = DynamicConfigurationService;
+exports.EmbeddedModule = EmbeddedModule;
+exports.FluxoClientBase = FluxoClientBase;
+exports.FluxoClientSys = FluxoClientSys;
+exports.FluxoStateDispatcher = FluxoStateDispatcher;
+exports.HttpClient = HttpClient;
+exports.IntellisenseService = IntellisenseService;
+exports.PermissionService = PermissionService;
+exports.PrintingService = PrintingService;
+exports.ReportingService = ReportingService;
+exports.RouteRuleService = RouteRuleService;
+exports.ServerFilterHelper = ServerFilterHelper;
+exports.UserService = UserService;
+exports.WorkflowService = WorkflowService;