@flagship.io/js-sdk/dist/index.browser.commonjs.js

Flagship JS SDK

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

/***/ 34:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isCallable = __webpack_require__(4901);

module.exports = function (it) {
  return typeof it == 'object' ? it !== null : isCallable(it);
};


/***/ }),

/***/ 81:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var call = __webpack_require__(9565);
var aCallable = __webpack_require__(9306);
var anObject = __webpack_require__(8551);
var tryToString = __webpack_require__(6823);
var getIteratorMethod = __webpack_require__(851);

var $TypeError = TypeError;

module.exports = function (argument, usingIterator) {
  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
  throw new $TypeError(tryToString(argument) + ' is not iterable');
};


/***/ }),

/***/ 111:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  launchQaAssistant: () => (/* binding */ launchQaAssistant)
});

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
var defineProperty = __webpack_require__(4467);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.find.js
var es_array_find = __webpack_require__(113);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.includes.js
var es_array_includes = __webpack_require__(4423);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.iterator.js
var es_array_iterator = __webpack_require__(3792);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.function.name.js
var es_function_name = __webpack_require__(2010);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.keys.js
var es_object_keys = __webpack_require__(9432);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.to-string.js
var es_object_to_string = __webpack_require__(6099);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.exec.js
var es_regexp_exec = __webpack_require__(7495);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.includes.js
var es_string_includes = __webpack_require__(1699);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.iterator.js
var es_string_iterator = __webpack_require__(7764);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.search.js
var es_string_search = __webpack_require__(5746);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom-collections.iterator.js
var web_dom_collections_iterator = __webpack_require__(2953);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.js
var web_url_search_params = __webpack_require__(8408);
// EXTERNAL MODULE: ./src/enum/FlagshipConstant.ts
var FlagshipConstant = __webpack_require__(2932);
// EXTERNAL MODULE: ./src/utils/utils.ts
var utils = __webpack_require__(6517);
;// ./src/qaAssistant/web/appendScript.ts

var getScriptElement = function getScriptElement(src) {
  return document.querySelector("script[src*=\"".concat(src, "\"]"));
};
/**
 *
 * @param bundleFileUrl
 */
function appendScript(bundleFileUrl) {
  if (getScriptElement(FlagshipConstant.TAG_QA_URL) || getScriptElement(FlagshipConstant.FS_QA_URL)) {
    return;
  }
  var script = document.createElement('script');
  script.src = bundleFileUrl;
  script.id = FlagshipConstant.FS_QA_ASSISTANT_SCRIPT_TAG_ID;
  if (bundleFileUrl === FlagshipConstant.QA_ASSISTANT_LOCAL_URL) {
    script.crossOrigin = 'anonymous';
  }
  document.body.append(script);
}
// EXTERNAL MODULE: ./src/qaAssistant/web/type.ts
var type = __webpack_require__(9788);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.filter.js
var es_array_filter = __webpack_require__(2008);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.for-each.js
var es_array_for_each = __webpack_require__(1629);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.date.to-json.js
var es_date_to_json = __webpack_require__(739);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.symbol.js
var es_symbol = __webpack_require__(2675);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.get-own-property-descriptor.js
var es_object_get_own_property_descriptor = __webpack_require__(3851);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.get-own-property-descriptors.js
var es_object_get_own_property_descriptors = __webpack_require__(1278);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom-collections.for-each.js
var web_dom_collections_for_each = __webpack_require__(3500);
// EXTERNAL MODULE: ./src/qaAssistant/web/messages/index.ts
var messages = __webpack_require__(531);
;// ./src/qaAssistant/web/messages/iframeMessageActions.ts

function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }















function onQaAssistantReady(visitorVariationState) {
  if (visitorVariationState.visitorVariations) {
    (0,messages.sendVisitorAllocatedVariations)(visitorVariationState);
  }
  if (visitorVariationState.exposedVariations) {
    (0,messages.sendVisitorExposedVariations)(visitorVariationState);
  }
}
function render() {
  var forcedReFetchFlags = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
  if (FlagshipConstant.SDK_INFO.name === 'TypeScript') {
    window.location.reload();
  }
  var triggerRenderEvent = new CustomEvent(type.INTERNAL_EVENTS.FsTriggerRendering, {
    detail: {
      forcedReFetchFlags: forcedReFetchFlags
    }
  });
  window.dispatchEvent(triggerRenderEvent);
}
function onQaAssistantClose(_ref) {
  var _document$getElementB;
  var config = _ref.config,
    func = _ref.func,
    visitorVariationState = _ref.visitorVariationState;
  config.isQAModeEnabled = false;
  sessionStorage.removeItem(FlagshipConstant.FS_IS_QA_MODE_ENABLED);
  if (func) {
    window.removeEventListener('message', func);
  }
  (_document$getElementB = document.getElementById(FlagshipConstant.FS_QA_ASSISTANT_SCRIPT_TAG_ID)) == null || _document$getElementB.remove();
  visitorVariationState.forcedVariations = {};
  render();
}
function onApplyForcedVariations(_ref2) {
  var value = _ref2.value,
    visitorVariationState = _ref2.visitorVariationState;
  var sessionForcedVariations = sessionStorage.getItem(FlagshipConstant.FS_FORCED_VARIATIONS);
  var forcedVariations = {};
  try {
    forcedVariations = JSON.parse(sessionForcedVariations || '{}');
  } catch (error) {
    // eslint-disable-next-line no-console
    console.error('Error parsing sessionForcedVariations', error);
  }
  forcedVariations = _objectSpread(_objectSpread({}, forcedVariations), value);
  sessionStorage.setItem(FlagshipConstant.FS_FORCED_VARIATIONS, JSON.stringify(forcedVariations));
  visitorVariationState.forcedVariations = forcedVariations;
  render();
}
function onResetForcedVariations(visitorVariationState) {
  sessionStorage.removeItem(FlagshipConstant.FS_FORCED_VARIATIONS);
  visitorVariationState.forcedVariations = {};
  render();
}
function removeForcedVariation(keys, visitorVariationState) {
  var sessionForcedVariations = sessionStorage.getItem(FlagshipConstant.FS_FORCED_VARIATIONS);
  var forcedVariations = {};
  try {
    forcedVariations = JSON.parse(sessionForcedVariations || '{}');
  } catch (error) {
    // eslint-disable-next-line no-console
    console.error('Error parsing sessionForcedVariations', error);
  }
  keys.forEach(function (key) {
    delete forcedVariations[key];
  });
  sessionStorage.setItem(FlagshipConstant.FS_FORCED_VARIATIONS, JSON.stringify(forcedVariations));
  visitorVariationState.forcedVariations = forcedVariations;
}
function onRemoveForcedVariation(_ref3) {
  var keys = _ref3.keys,
    visitorVariationState = _ref3.visitorVariationState;
  removeForcedVariation(keys, visitorVariationState);
  visitorVariationState.shouldForceRender = true;
  render(true);
}
function onVariationsForcedAllocation(_ref4) {
  var value = _ref4.value,
    visitorVariationState = _ref4.visitorVariationState;
  sessionStorage.setItem(FlagshipConstant.FS_VARIATIONS_FORCED_ALLOCATION, JSON.stringify(value));
  var variationsForcedAllocation = visitorVariationState.variationsForcedAllocation || {};
  var diffVariationKeys = Object.keys(variationsForcedAllocation).filter(function (key) {
    return !(key in value);
  });
  if (diffVariationKeys.length > 0) {
    removeForcedVariation(diffVariationKeys, visitorVariationState);
  }
  visitorVariationState.variationsForcedAllocation = value;
  visitorVariationState.shouldForceRender = true;
  render(true);
}
function onVariationsForcedUnallocation(_ref5) {
  var value = _ref5.value,
    visitorVariationState = _ref5.visitorVariationState;
  sessionStorage.setItem(FlagshipConstant.FS_VARIATIONS_FORCED_UNALLOCATION, JSON.stringify(value));
  visitorVariationState.variationsForcedUnallocation = value;
  visitorVariationState.shouldForceRender = true;
  render(true);
}
;// ./src/qaAssistant/web/messages/handleIframeMessage.ts




function handleIframeMessage(_ref) {
  var event = _ref.event,
    config = _ref.config,
    func = _ref.func,
    visitorVariationState = _ref.visitorVariationState;
  if (!config.isQAModeEnabled || !(0,utils.isBrowser)()) {
    return;
  }
  switch (event.data.name) {
    case type.MSG_NAME_FROM_IFRAME.FsQaAssistantReady:
      onQaAssistantReady(visitorVariationState);
      break;
    case type.MSG_NAME_FROM_IFRAME.MinimizeQaAssistantClose:
    case type.MSG_NAME_FROM_IFRAME.QaAssistantClose:
      onQaAssistantClose({
        config: config,
        func: func,
        visitorVariationState: visitorVariationState
      });
      break;
    case type.MSG_NAME_FROM_IFRAME.FsApplyForcedVariations:
      onApplyForcedVariations({
        value: event.data.value,
        visitorVariationState: visitorVariationState
      });
      break;
    case type.MSG_NAME_FROM_IFRAME.FsResetForcedVariations:
      onResetForcedVariations(visitorVariationState);
      break;
    case type.MSG_NAME_FROM_IFRAME.FsTriggerRender:
      render(true);
      break;
    case type.MSG_NAME_FROM_IFRAME.FsVariationsForcedAllocation:
      onVariationsForcedAllocation({
        value: event.data.value,
        visitorVariationState: visitorVariationState
      });
      break;
    case type.MSG_NAME_FROM_IFRAME.FsVariationsForcedUnallocation:
      onVariationsForcedUnallocation({
        value: event.data.value,
        visitorVariationState: visitorVariationState
      });
      break;
    case type.MSG_NAME_FROM_IFRAME.FsRemoveForcedVariation:
      onRemoveForcedVariation({
        keys: event.data.value,
        visitorVariationState: visitorVariationState
      });
      break;
  }
}
;// ./src/qaAssistant/web/loadQaAssistant.ts







function loadSessionVariations(key) {
  var sessionData = sessionStorage.getItem(key);
  var variations = {};
  try {
    variations = JSON.parse(sessionData || '{}');
  } catch (error) {
    // eslint-disable-next-line no-console
    console.error("Error parsing ".concat(key), error);
  }
  return variations;
}

/**
 *
 * @param config
 * @returns
 */
function loadQaAssistant(config) {
  var _window;
  var bundleUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  var visitorVariationState = arguments.length > 2 ? arguments[2] : undefined;
  if (!((_window = window) != null && (_window = _window.frames) != null && _window.ABTastyQaAssistant)) {
    (0,utils.logInfoSprintf)(config, 'QA assistant', 'Loading QA Assistant');
    appendScript(bundleUrl || FlagshipConstant.QA_ASSISTANT_PROD_URL);
  }
  visitorVariationState.forcedVariations = loadSessionVariations(FlagshipConstant.FS_FORCED_VARIATIONS);
  visitorVariationState.variationsForcedAllocation = loadSessionVariations(FlagshipConstant.FS_VARIATIONS_FORCED_ALLOCATION);
  ;
  visitorVariationState.variationsForcedUnallocation = loadSessionVariations(FlagshipConstant.FS_VARIATIONS_FORCED_UNALLOCATION);
  ;
  if (window.__flagshipSdkQaAssistantMessageHandler) {
    window.removeEventListener('message', window.__flagshipSdkQaAssistantMessageHandler);
  }
  var _eventListenerMessage = function eventListenerMessage(event) {
    if (!FlagshipConstant.TRUSTED_QA_ORIGINS.includes(event == null ? void 0 : event.origin)) {
      return;
    }
    handleIframeMessage({
      visitorVariationState: visitorVariationState,
      event: event,
      config: config,
      func: _eventListenerMessage
    });
  };
  window.__flagshipSdkQaAssistantMessageHandler = _eventListenerMessage;
  window.addEventListener('message', window.__flagshipSdkQaAssistantMessageHandler);
  config.isQAModeEnabled = true;
  sessionStorage.setItem(FlagshipConstant.FS_IS_QA_MODE_ENABLED, 'true');
}
;// ./src/qaAssistant/web/listenForKeyboardQaAssistant.ts




/**
 *
 * @param config
 */
function listenForKeyboardQaAssistant(config, visitorVariationState) {
  (0,utils.logInfoSprintf)(config, 'QA assistant', 'Listening for keyboard events to launch QA Assistant');
  if (window.__flagshipSdkOnKeyCombinationDown) {
    document.removeEventListener('keydown', window.__flagshipSdkOnKeyCombinationDown);
  }
  if (window.__flagshipSdkOnKeyCombinationUp) {
    document.removeEventListener('keyup', window.__flagshipSdkOnKeyCombinationUp);
  }
  var keysPressed = {};
  var keyCombinationPressed = function keyCombinationPressed() {
    return (keysPressed.Control || keysPressed.Alt) && keysPressed.q && keysPressed.a;
  };
  window.__flagshipSdkOnKeyCombinationDown = function (event) {
    keysPressed[event.key] = true;
    sessionStorage.removeItem(FlagshipConstant.FS_FORCED_VARIATIONS);
    if (keyCombinationPressed()) {
      loadQaAssistant(config, null, visitorVariationState);
    }
  };
  window.__flagshipSdkOnKeyCombinationUp = function (event) {
    delete keysPressed[event.key];
  };
  document.addEventListener('keydown', window.__flagshipSdkOnKeyCombinationDown);
  document.addEventListener('keyup', window.__flagshipSdkOnKeyCombinationUp);
}
;// ./src/qaAssistant/web/detectNavigationChanges.ts
function detectNavigationChanges(config, visitorVariationState, callback) {
  if (window.__flagshipSdkOriginalPushState) {
    window.history.pushState = window.__flagshipSdkOriginalPushState;
  }
  if (window.__flagshipSdkOriginalReplaceState) {
    window.history.replaceState = window.__flagshipSdkOriginalReplaceState;
  }
  if (window.__flagshipSdkPopStateHandler) {
    window.removeEventListener('popstate', window.__flagshipSdkPopStateHandler);
  }
  window.__flagshipSdkOriginalPushState = window.history.pushState;
  window.__flagshipSdkOriginalReplaceState = window.history.replaceState;
  function triggerCallback() {
    if (config.isQAModeEnabled) {
      visitorVariationState.navigationDetected = true;
      callback == null || callback();
    }
  }
  window.history.pushState = function () {
    if (window.__flagshipSdkOriginalPushState) {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      window.__flagshipSdkOriginalPushState.apply(this, args);
      triggerCallback();
    }
  };
  window.history.replaceState = function () {
    if (window.__flagshipSdkOriginalReplaceState) {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }
      window.__flagshipSdkOriginalReplaceState.apply(this, args);
      triggerCallback();
    }
  };
  window.__flagshipSdkPopStateHandler = function () {
    triggerCallback();
  };
  window.addEventListener('popstate', window.__flagshipSdkPopStateHandler);
}
;// ./src/qaAssistant/web/index.ts




















/**
 *
 * @param config
 * @returns
 */
function launchQaAssistant(config, visitorVariationState) {
  if (!(0,utils.isBrowser)()) {
    return;
  }
  (0,utils.onDomReady)(function () {
    var urlMap = (0,defineProperty["default"])((0,defineProperty["default"])((0,defineProperty["default"])((0,defineProperty["default"])((0,defineProperty["default"])((0,defineProperty["default"])({}, FlagshipConstant.FS_QA_ASSISTANT, FlagshipConstant.QA_ASSISTANT_PROD_URL), FlagshipConstant.TAG_QA_ASSISTANT, FlagshipConstant.QA_ASSISTANT_PROD_URL), FlagshipConstant.FS_QA_ASSISTANT_STAGING, FlagshipConstant.QA_ASSISTANT_STAGING_URL), FlagshipConstant.TAG_QA_ASSISTANT_STAGING, FlagshipConstant.QA_ASSISTANT_STAGING_URL), FlagshipConstant.FS_QA_ASSISTANT_LOCAL, FlagshipConstant.QA_ASSISTANT_LOCAL_URL), FlagshipConstant.TAG_QA_ASSISTANT_LOCAL, FlagshipConstant.QA_ASSISTANT_LOCAL_URL);
    var queryParam = new URLSearchParams(window.location.search);
    var urlKey = Object.keys(urlMap).find(function (key) {
      return queryParam.get(key) === 'true';
    }) || '';
    if (window.__flagshipSdkOnPlatformChoiceLoaded) {
      window.removeEventListener('message', window.__flagshipSdkOnPlatformChoiceLoaded);
    }
    function onPlatformChoiceLoaded(event) {
      if (!FlagshipConstant.TRUSTED_QA_ORIGINS.includes(event.origin)) {
        return;
      }
      if (event.data.name === type.MSG_NAME_FROM_IFRAME.QaAssistantPlatformChoiceLoaded) {
        if (!config.isQAModeEnabled) {
          loadQaAssistant(config, null, visitorVariationState);
        }
        window.removeEventListener('message', onPlatformChoiceLoaded);
      }
    }
    window.__flagshipSdkOnPlatformChoiceLoaded = onPlatformChoiceLoaded;
    window.addEventListener('message', window.__flagshipSdkOnPlatformChoiceLoaded);
    detectNavigationChanges(config, visitorVariationState);
    if (config.isQAModeEnabled || urlKey) {
      loadQaAssistant(config, urlMap[urlKey], visitorVariationState);
      return;
    }
    listenForKeyboardQaAssistant(config, visitorVariationState);
  });
}

/***/ }),

/***/ 113:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var $ = __webpack_require__(6518);
var $find = (__webpack_require__(9213).find);
var addToUnscopables = __webpack_require__(6469);

var FIND = 'find';
var SKIPS_HOLES = true;

// Shouldn't skip holes
// eslint-disable-next-line es/no-array-prototype-find -- testing
if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });

// `Array.prototype.find` method
// https://tc39.es/ecma262/#sec-array.prototype.find
$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
  find: function find(callbackfn /* , that = undefined */) {
    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
  }
});

// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables(FIND);


/***/ }),

/***/ 235:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var $forEach = (__webpack_require__(9213).forEach);
var arrayMethodIsStrict = __webpack_require__(4598);

var STRICT_METHOD = arrayMethodIsStrict('forEach');

// `Array.prototype.forEach` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.foreach
module.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
  return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
} : [].forEach;


/***/ }),

/***/ 280:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var $ = __webpack_require__(6518);
var getBuiltIn = __webpack_require__(7751);
var IS_PURE = __webpack_require__(6395);
var NativePromiseConstructor = __webpack_require__(550);
var FORCED_PROMISE_CONSTRUCTOR = (__webpack_require__(916).CONSTRUCTOR);
var promiseResolve = __webpack_require__(3438);

var PromiseConstructorWrapper = getBuiltIn('Promise');
var CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;

// `Promise.resolve` method
// https://tc39.es/ecma262/#sec-promise.resolve
$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {
  resolve: function resolve(x) {
    return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);
  }
});


/***/ }),

/***/ 283:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(9504);
var fails = __webpack_require__(9039);
var isCallable = __webpack_require__(4901);
var hasOwn = __webpack_require__(9297);
var DESCRIPTORS = __webpack_require__(3724);
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(350).CONFIGURABLE);
var inspectSource = __webpack_require__(3706);
var InternalStateModule = __webpack_require__(1181);

var enforceInternalState = InternalStateModule.enforce;
var getInternalState = InternalStateModule.get;
var $String = String;
// eslint-disable-next-line es/no-object-defineproperty -- safe
var defineProperty = Object.defineProperty;
var stringSlice = uncurryThis(''.slice);
var replace = uncurryThis(''.replace);
var join = uncurryThis([].join);

var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
});

var TEMPLATE = String(String).split('String');

var makeBuiltIn = module.exports = function (value, name, options) {
  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
  }
  if (options && options.getter) name = 'get ' + name;
  if (options && options.setter) name = 'set ' + name;
  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
    else value.name = name;
  }
  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
    defineProperty(value, 'length', { value: options.arity });
  }
  try {
    if (options && hasOwn(options, 'constructor') && options.constructor) {
      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
    } else if (value.prototype) value.prototype = undefined;
  } catch (error) { /* empty */ }
  var state = enforceInternalState(value);
  if (!hasOwn(state, 'source')) {
    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
  } return value;
};

// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
// eslint-disable-next-line no-extend-native -- required
Function.prototype.toString = makeBuiltIn(function toString() {
  return isCallable(this) && getInternalState(this).source || inspectSource(this);
}, 'toString');


/***/ }),

/***/ 298:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

/* eslint-disable es/no-object-getownpropertynames -- safe */
var classof = __webpack_require__(4576);
var toIndexedObject = __webpack_require__(5397);
var $getOwnPropertyNames = (__webpack_require__(8480).f);
var arraySlice = __webpack_require__(7680);

var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
  ? Object.getOwnPropertyNames(window) : [];

var getWindowNames = function (it) {
  try {
    return $getOwnPropertyNames(it);
  } catch (error) {
    return arraySlice(windowNames);
  }
};

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
module.exports.f = function getOwnPropertyNames(it) {
  return windowNames && classof(it) === 'Window'
    ? getWindowNames(it)
    : $getOwnPropertyNames(toIndexedObject(it));
};


/***/ }),

/***/ 350:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(3724);
var hasOwn = __webpack_require__(9297);

var FunctionPrototype = Function.prototype;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;

var EXISTS = hasOwn(FunctionPrototype, 'name');
// additional protection from minified / mangled / dropped function names
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));

module.exports = {
  EXISTS: EXISTS,
  PROPER: PROPER,
  CONFIGURABLE: CONFIGURABLE
};


/***/ }),

/***/ 380:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(9504);
var fails = __webpack_require__(9039);
var padStart = (__webpack_require__(533).start);

var $RangeError = RangeError;
var $isFinite = isFinite;
var abs = Math.abs;
var DatePrototype = Date.prototype;
var nativeDateToISOString = DatePrototype.toISOString;
var thisTimeValue = uncurryThis(DatePrototype.getTime);
var getUTCDate = uncurryThis(DatePrototype.getUTCDate);
var getUTCFullYear = uncurryThis(DatePrototype.getUTCFullYear);
var getUTCHours = uncurryThis(DatePrototype.getUTCHours);
var getUTCMilliseconds = uncurryThis(DatePrototype.getUTCMilliseconds);
var getUTCMinutes = uncurryThis(DatePrototype.getUTCMinutes);
var getUTCMonth = uncurryThis(DatePrototype.getUTCMonth);
var getUTCSeconds = uncurryThis(DatePrototype.getUTCSeconds);

// `Date.prototype.toISOString` method implementation
// https://tc39.es/ecma262/#sec-date.prototype.toisostring
// PhantomJS / old WebKit fails here:
module.exports = (fails(function () {
  return nativeDateToISOString.call(new Date(-5e13 - 1)) !== '0385-07-25T07:06:39.999Z';
}) || !fails(function () {
  nativeDateToISOString.call(new Date(NaN));
})) ? function toISOString() {
  if (!$isFinite(thisTimeValue(this))) throw new $RangeError('Invalid time value');
  var date = this;
  var year = getUTCFullYear(date);
  var milliseconds = getUTCMilliseconds(date);
  var sign = year < 0 ? '-' : year > 9999 ? '+' : '';
  return sign + padStart(abs(year), sign ? 6 : 4, 0) +
    '-' + padStart(getUTCMonth(date) + 1, 2, 0) +
    '-' + padStart(getUTCDate(date), 2, 0) +
    'T' + padStart(getUTCHours(date), 2, 0) +
    ':' + padStart(getUTCMinutes(date), 2, 0) +
    ':' + padStart(getUTCSeconds(date), 2, 0) +
    '.' + padStart(milliseconds, 3, 0) +
    'Z';
} : nativeDateToISOString;


/***/ }),

/***/ 397:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var getBuiltIn = __webpack_require__(7751);

module.exports = getBuiltIn('document', 'documentElement');


/***/ }),

/***/ 421:
/***/ ((module) => {

"use strict";

module.exports = {};


/***/ }),

/***/ 436:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var $ = __webpack_require__(6518);
var IS_PURE = __webpack_require__(6395);
var IS_NODE = __webpack_require__(6193);
var globalThis = __webpack_require__(2195);
var call = __webpack_require__(9565);
var defineBuiltIn = __webpack_require__(6840);
var setPrototypeOf = __webpack_require__(2967);
var setToStringTag = __webpack_require__(687);
var setSpecies = __webpack_require__(7633);
var aCallable = __webpack_require__(9306);
var isCallable = __webpack_require__(4901);
var isObject = __webpack_require__(34);
var anInstance = __webpack_require__(679);
var speciesConstructor = __webpack_require__(2293);
var task = (__webpack_require__(9225).set);
var microtask = __webpack_require__(1955);
var hostReportErrors = __webpack_require__(3138);
var perform = __webpack_require__(1103);
var Queue = __webpack_require__(8265);
var InternalStateModule = __webpack_require__(1181);
var NativePromiseConstructor = __webpack_require__(550);
var PromiseConstructorDetection = __webpack_require__(916);
var newPromiseCapabilityModule = __webpack_require__(6043);

var PROMISE = 'Promise';
var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;
var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
var setInternalState = InternalStateModule.set;
var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
var PromiseConstructor = NativePromiseConstructor;
var PromisePrototype = NativePromisePrototype;
var TypeError = globalThis.TypeError;
var document = globalThis.document;
var process = globalThis.process;
var newPromiseCapability = newPromiseCapabilityModule.f;
var newGenericPromiseCapability = newPromiseCapability;

var DISPATCH_EVENT = !!(document && document.createEvent && globalThis.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;

// helpers
var isThenable = function (it) {
  var then;
  return isObject(it) && isCallable(then = it.then) ? then : false;
};

var callReaction = function (reaction, state) {
  var value = state.value;
  var ok = state.state === FULFILLED;
  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(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(new TypeError('Promise-chain cycle'));
      } else if (then = isThenable(result)) {
        call(then, result, resolve, reject);
      } else resolve(result);
    } else reject(value);
  } catch (error) {
    if (domain && !exited) domain.exit();
    reject(error);
  }
};

var notify = function (state, isReject) {
  if (state.notified) return;
  state.notified = true;
  microtask(function () {
    var reactions = state.reactions;
    var reaction;
    while (reaction = reactions.get()) {
      callReaction(reaction, state);
    }
    state.notified = false;
    if (isReject && !state.rejection) onUnhandled(state);
  });
};

var dispatchEvent = function (name, promise, reason) {
  var event, handler;
  if (DISPATCH_EVENT) {
    event = document.createEvent('Event');
    event.promise = promise;
    event.reason = reason;
    event.initEvent(name, false, true);
    globalThis.dispatchEvent(event);
  } else event = { promise: promise, reason: reason };
  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis['on' + name])) handler(event);
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
};

var onUnhandled = function (state) {
  call(task, globalThis, function () {
    var promise = state.facade;
    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 (state) {
  call(task, globalThis, function () {
    var promise = state.facade;
    if (IS_NODE) {
      process.emit('rejectionHandled', promise);
    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
  });
};

var bind = function (fn, state, unwrap) {
  return function (value) {
    fn(state, value, unwrap);
  };
};

var internalReject = function (state, value, unwrap) {
  if (state.done) return;
  state.done = true;
  if (unwrap) state = unwrap;
  state.value = value;
  state.state = REJECTED;
  notify(state, true);
};

var internalResolve = function (state, value, unwrap) {
  if (state.done) return;
  state.done = true;
  if (unwrap) state = unwrap;
  try {
    if (state.facade === value) throw new TypeError("Promise can't be resolved itself");
    var then = isThenable(value);
    if (then) {
      microtask(function () {
        var wrapper = { done: false };
        try {
          call(then, value,
            bind(internalResolve, wrapper, state),
            bind(internalReject, wrapper, state)
          );
        } catch (error) {
          internalReject(wrapper, error, state);
        }
      });
    } else {
      state.value = value;
      state.state = FULFILLED;
      notify(state, false);
    }
  } catch (error) {
    internalReject({ done: false }, error, state);
  }
};

// constructor polyfill
if (FORCED_PROMISE_CONSTRUCTOR) {
  // 25.4.3.1 Promise(executor)
  PromiseConstructor = function Promise(executor) {
    anInstance(this, PromisePrototype);
    aCallable(executor);
    call(Internal, this);
    var state = getInternalPromiseState(this);
    try {
      executor(bind(internalResolve, state), bind(internalReject, state));
    } catch (error) {
      internalReject(state, error);
    }
  };

  PromisePrototype = PromiseConstructor.prototype;

  // eslint-disable-next-line no-unused-vars -- required for `.length`
  Internal = function Promise(executor) {
    setInternalState(this, {
      type: PROMISE,
      done: false,
      notified: false,
      parent: false,
      reactions: new Queue(),
      rejection: false,
      state: PENDING,
      value: null
    });
  };

  // `Promise.prototype.then` method
  // https://tc39.es/ecma262/#sec-promise.prototype.then
  Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
    var state = getInternalPromiseState(this);
    var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
    state.parent = true;
    reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
    reaction.fail = isCallable(onRejected) && onRejected;
    reaction.domain = IS_NODE ? process.domain : undefined;
    if (state.state === PENDING) state.reactions.add(reaction);
    else microtask(function () {
      callReaction(reaction, state);
    });
    return reaction.promise;
  });

  OwnPromiseCapability = function () {
    var promise = new Internal();
    var state = getInternalPromiseState(promise);
    this.promise = promise;
    this.resolve = bind(internalResolve, state);
    this.reject = bind(internalReject, state);
  };

  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
    return C === PromiseConstructor || C === PromiseWrapper
      ? new OwnPromiseCapability(C)
      : newGenericPromiseCapability(C);
  };

  if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {
    nativeThen = NativePromisePrototype.then;

    if (!NATIVE_PROMISE_SUBCLASSING) {
      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
      defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
        var that = this;
        return new PromiseConstructor(function (resolve, reject) {
          call(nativeThen, that, resolve, reject);
        }).then(onFulfilled, onRejected);
      // https://github.com/zloirock/core-js/issues/640
      }, { unsafe: true });
    }

    // make `.constructor === Promise` work for native promise-based APIs
    try {
      delete NativePromisePrototype.constructor;
    } catch (error) { /* empty */ }

    // make `instanceof Promise` work for native promise-based APIs
    if (setPrototypeOf) {
      setPrototypeOf(NativePromisePrototype, PromisePrototype);
    }
  }
}

// `Promise` constructor
// https://tc39.es/ecma262/#sec-promise-executor
$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
  Promise: PromiseConstructor
});

setToStringTag(PromiseConstructor, PROMISE, false, true);
setSpecies(PROMISE);


/***/ }),

/***/ 511:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isRegExp = __webpack_require__(788);

var $TypeError = TypeError;

module.exports = function (it) {
  if (isRegExp(it)) {
    throw new $TypeError("The method doesn't accept regular expressions");
  } return it;
};


/***/ }),

/***/ 531:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   sendFsHitToQA: () => (/* binding */ sendFsHitToQA),
/* harmony export */   sendVisitorAllocatedVariations: () => (/* binding */ sendVisitorAllocatedVariations),
/* harmony export */   sendVisitorExposedVariations: () => (/* binding */ sendVisitorExposedVariations)
/* harmony export */ });
/* unused harmony export sendMessageToIframe */
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4467);
/* harmony import */ var core_js_modules_es_array_map_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2062);
/* harmony import */ var core_js_modules_es_array_map_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_map_js__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var core_js_modules_es_symbol_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2675);
/* harmony import */ var core_js_modules_es_symbol_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_symbol_js__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var core_js_modules_es_array_filter_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2008);
/* harmony import */ var core_js_modules_es_array_filter_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_filter_js__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var core_js_modules_es_array_for_each_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1629);
/* harmony import */ var core_js_modules_es_array_for_each_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_for_each_js__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var core_js_modules_es_object_get_own_property_descriptor_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(3851);
/* harmony import */ var core_js_modules_es_object_get_own_property_descriptor_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_object_get_own_property_descriptor_js__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var core_js_modules_es_object_get_own_property_descriptors_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1278);
/* harmony import */ var core_js_modules_es_object_get_own_property_descriptors_js__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_object_get_own_property_descriptors_js__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var core_js_modules_es_object_keys_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(9432);
/* harmony import */ var core_js_modules_es_object_keys_js__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_object_keys_js__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var core_js_modules_es_object_to_string_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(6099);
/* harmony import */ var core_js_modules_es_object_to_string_js__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_object_to_string_js__WEBPACK_IMPORTED_MODULE_8__);
/* harmony import */ var core_js_modules_web_dom_collections_for_each_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(3500);
/* harmony import */ var core_js_modules_web_dom_collections_for_each_js__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_collections_for_each_js__WEBPACK_IMPORTED_MODULE_9__);
/* harmony import */ var _type__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(9788);

function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }










function sendMessageToIframe(data) {
  var _window;
  if (!((_window = window) != null && (_window = _window.frames) != null && _window.ABTastyQaAssistant)) {
    return;
  }
  window.frames.ABTastyQaAssistant.postMessage(data, '*');
}
function sendVisitorAllocatedVariations(visitorVariationState) {
  if (!(visitorVariationState != null && visitorVariationState.visitorVariations)) {
    return;
  }
  sendMessageToIframe({
    name: _type__WEBPACK_IMPORTED_MODULE_10__.MSG_NAME_TO_IFRAME.FsUpdateVisitorAllocatedVariation,
    value: visitorVariationState.visitorVariations,
    visitorData: visitorVariationState.visitorData,
    sdkInfo: visitorVariationState.sdkInfo
  });
}
function sendVisitorExposedVariations(visitorVariationState) {
  if (!(visitorVariationState != null && visitorVariationState.exposedVariations)) {
    return;
  }
  var navigationDetected = visitorVariationState.navigationDetected;
  if (visitorVariationState.navigationDetected) {
    visitorVariationState.navigationDetected = false;
  }
  sendMessageToIframe({
    name: _type__WEBPACK_IMPORTED_MODULE_10__.MSG_NAME_TO_IFRAME.FsVisitorExposedVariation,
    value: visitorVariationState.exposedVariations,
    param: navigationDetected ? _type__WEBPACK_IMPORTED_MODULE_10__.VisitorVariationUpdateParam.NewNavigation : undefined
  });
}
function sendFsHitToQA(hit) {
  sendMessageToIframe({
    name: _type__WEBPACK_IMPORTED_MODULE_10__.MSG_NAME_TO_IFRAME.FsHIT,
    value: hit.map(function (item) {
      return _objectSpread(_objectSpread({}, item), {}, {
        timestamp: Date.now() - item.qt
      });
    })
  });
}

/***/ }),

/***/ 533:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

// https://github.com/tc39/proposal-string-pad-start-end
var uncurryThis = __webpack_require__(9504);
var toLength = __webpack_require__(8014);
var toString = __webpack_require__(655);
var $repeat = __webpack_require__(2333);
var requireObjectCoercible = __webpack_require__(7750);

var repeat = uncurryThis($repeat);
var stringSlice = uncurryThis(''.slice);
var ceil = Math.ceil;

// `String.prototype.{ padStart, padEnd }` methods implementation
var createMethod = function (IS_END) {
  return function ($this, maxLength, fillString) {
    var S = toString(requireObjectCoercible($this));
    var intMaxLength = toLength(maxLength);
    var stringLength = S.length;
    var fillStr = fillString === undefined ? ' ' : toString(fillString);
    var fillLen, stringFiller;
    if (intMaxLength <= stringLength || fillStr === '') return S;
    fillLen = intMaxLength - stringLength;
    stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length));
    if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen);
    return IS_END ? S + stringFiller : stringFiller + S;
  };
};

module.exports = {
  // `String.prototype.padStart` method
  // https://tc39.es/ecma262/#sec-string.prototype.padstart
  start: createMethod(false),
  // `String.prototype.padEnd` method
  // https://tc39.es/ecma262/#sec-string.prototype.padend
  end: createMethod(true)
};


/***/ }),

/***/ 537:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var NativePromiseConstructor = __webpack_require__(550);
var checkCorrectnessOfIteration = __webpack_require__(4428);
var FORCED_PROMISE_CONSTRUCTOR = (__webpack_require__(916).CONSTRUCTOR);

module.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {
  NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });
});


/***/ }),

/***/ 550:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var globalThis = __webpack_require__(2195);

module.exports = globalThis.Promise;


/***/ }),

/***/ 566:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(9504);
var aCallable = __webpack_require__(9306);
var isObject = __webpack_require__(34);
var hasOwn = __webpack_require__(9297);
var arraySlice = __webpack_require__(7680);
var NATIVE_BIND = __webpack_require__(616);

var $Function = Function;
var concat = uncurryThis([].concat);
var join = uncurryThis([].join);
var factories = {};

var construct = function (C, argsLength, args) {
  if (!hasOwn(factories, argsLength)) {
    var list = [];
    var i = 0;
    for (; i < argsLength; i++) list[i] = 'a[' + i + ']';
    factories[argsLength] = $Function('C,a', 'return new C(' + join(list, ',') + ')');
  } return factories[argsLength](C, args);
};

// `Function.prototype.bind` method implementation
// https://tc39.es/ecma262/#sec-function.prototype.bind
// eslint-disable-next-line es/no-function-prototype-bind -- detection
module.exports = NATIVE_BIND ? $Function.bind : function bind(that /* , ...args */) {
  var F = aCallable(this);
  var Prototype = F.prototype;
  var partArgs = arraySlice(arguments, 1);
  var boundFunction = function bound(/* args... */) {
    var args = concat(partArgs, arraySlice(arguments));
    return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args);
  };
  if (isObject(Prototype)) boundFunction.prototype = Prototype;
  return boundFunction;
};


/***/ }),

/***/ 597:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var fails = __webpack_require__(9039);
var wellKnownSymbol = __webpack_require__(8227);
var V8_VERSION = __webpack_require__(9519);

var SPECIES = wellKnownSymbol('species');

module.exports = function (METHOD_NAME) {
  // We can't use this feature detection in V8 since it causes
  // deoptimization and serious performance degradation
  // https://github.com/zloirock/core-js/issues/677
  return V8_VERSION >= 51 || !fails(function () {
    var array = [];
    var constructor = array.constructor = {};
    constructor[SPECIES] = function () {
      return { foo: 1 };
    };
    return array[METHOD_NAME](Boolean).foo !== 1;
  });
};


/***/ }),

/***/ 616:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var fails = __webpack_require__(9039);

module.exports = !fails(function () {
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
  var test = (function () { /* empty */ }).bind();
  // eslint-disable-next-line no-prototype-builtins -- safe
  return typeof test != 'function' || test.hasOwnProperty('prototype');
});


/***/ }),

/***/ 655:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var classof = __webpack_require__(6955);

var $String = String;

module.exports = function (argument) {
  if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
  return $String(argument);
};


/***/ }),

/***/ 679:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isPrototypeOf = __webpack_require__(1625);

var $TypeError = TypeError;

module.exports = function (it, Prototype) {
  if (isPrototypeOf(Prototype, it)) return it;
  throw new $TypeError('Incorrect invocation');
};


/***/ }),

/***/ 687:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var defineProperty = (__webpack_require__(4913).f);
var hasOwn = __webpack_require__(9297);
var wellKnownSymbol = __webpack_require__(8227);

var TO_STRING_TAG = wellKnownSymbol('toStringTag');

module.exports = function (target, TAG, STATIC) {
  if (target && !STATIC) target = target.prototype;
  if (target && !hasOwn(target, TO_STRING_TAG)) {
    defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
  }
};


/***/ }),

/***/ 739:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var $ = __webpack_require__(6518);
var fails = __webpack_require__(9039);
var toObject = __webpack_require__(8981);
var toPrimitive = __webpack_require__(2777);

var FORCED = fails(function () {
  return new Date(NaN).toJSON() !== null
    || Date.prototype.toJSON.call({ toISOString: f