@bigbinary/neeto-commons-frontend 2.0.30 → 2.0.32

package/cypress-utils.cjs.js

@@ -0,0 +1,1760 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('Support/utils/common');
+require('@bigbinary/neetoui');
+require('i18next');
+var ramda = require('ramda');
+var dayjs = require('dayjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+function _typeof$1(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof$1(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof$1(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof$1(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof$1(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+var environment = {
+  development: "development",
+  staging: "staging"
+};
+var isStagingEnv = Cypress.env("configFile") === environment.staging;
+
+var getCountFromText = function getCountFromText(countText) {
+  return Number(countText.text().trim().split(" ")[0]);
+};
+var dataCy = function dataCy(value) {
+  var suffix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+  return "[data-cy='".concat(value, "']").concat(suffix);
+};
+var setListCount = function setListCount(countSelector, alias) {
+  return cy.get(countSelector).then(function (countText) {
+    cy.wrap(getCountFromText(countText)).as(alias);
+  });
+};
+var verifyListCount = function verifyListCount(countSelector, count) {
+  return cy.get(countSelector).then(function (countText) {
+    cy.wrap(getCountFromText(countText)).should("eq", count);
+  });
+};
+var getUrl = function getUrl(path) {
+  return "/api/v1/".concat(path);
+};
+var getTestTitle = function getTestTitle() {
+  var ctx = Cypress.mocha.getRunner().suite.ctx;
+  return ctx.currentTest.parent.title;
+};
+var initializeCredentials = function initializeCredentials(stagingData) {
+  cy.task("getGlobalState").then(function (state) {
+    var newState = {
+      businessName: state.businessName || stagingData.businessName,
+      currentUserName: state.currentUserName || stagingData.currentUserName,
+      email: state.email || stagingData.email,
+      firstName: state.firstName || stagingData.firstName,
+      lastName: state.lastName || stagingData.lastName,
+      subdomainName: state.subdomainName || stagingData.subdomainName,
+      skipSetup: state.skipSetup
+    };
+    if (isStagingEnv) {
+      var baseUrl = "https://".concat(newState.subdomainName, ".").concat(stagingData.domain);
+      Cypress.config("baseUrl", baseUrl);
+    }
+    cy.task("bulkUpdateGlobalState", newState);
+  });
+};
+
+var allPath = function allPath() {
+  return "".concat(Cypress.config("baseUrl")).concat(getUrl("**"));
+};
+var requestApis = {
+  countries: getUrl("countries"),
+  signUp: getUrl("signups/**"),
+  subdomainAvailablity: getUrl("subdomain_availability/**"),
+  teamMembers: {
+    all: "/team_members*/**",
+    bulkUpdate: "/team_members/teams/bulk_update",
+    index: "/team_members/teams"
+  }
+};
+var urlPaths = {
+  members: "/desk/members"
+};
+Object.defineProperty(requestApis, "allPath", {
+  get: allPath
+});
+
+var commonSelectors = {
+  alertTitle: dataCy("alert-title"),
+  alertModalMessage: dataCy("alert-message"),
+  alertModalSubmitButton: dataCy("alert-submit-button"),
+  checkbox: ".neeto-ui-checkbox",
+  checkboxLabel: dataCy("nui-checkbox-label"),
+  dropdownContainer: dataCy("nui-dropdown-container"),
+  dropdownIcon: dataCy("nui-dropdown-icon"),
+  heading: dataCy("main-header"),
+  paneBody: ".neeto-ui-pane__body",
+  paneHeader: ".neeto-ui-pane__header",
+  profileSidebar: ".neeto-ui-profile-sidebar",
+  selectOption: ".neeto-ui-react-select__option",
+  toastMessage: dataCy("toastr-message-container"),
+  toastCloseButton: ".neeto-ui-toastr__close-button",
+  windowAlert: "#alert-box"
+};
+var tableSelectors = {
+  nthColumn: function nthColumn(n) {
+    return "td:nth-child(".concat(n, ")");
+  },
+  tableBody: ".ant-table-body",
+  tableHeader: ".ant-table-thead th",
+  tableRow: ".ant-table-tbody tr",
+  spinner: ".ant-spin"
+};
+var profileSelectors = {
+  logoutLink: dataCy("profile-logout-button"),
+  profileOptionsContainer: '[class="tippy-box sidebar-featured-tooltip__content"]'
+};
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+Cypress.Commands.add("clearAndType", function (selector, text) {
+  cy.get(selector).clear().type(text);
+});
+Cypress.Commands.add("clearAndTypeFast", function (selector, text) {
+  cy.get(selector).clear().type(text, {
+    delay: 0
+  });
+});
+Cypress.Commands.add("clearByClickAndTypeFast", function (selector, text) {
+  cy.get(selector).click().clear().type(text, {
+    delay: 0
+  });
+});
+Cypress.Commands.add("typeFast", function (selector, text) {
+  cy.get(selector).type(text, {
+    delay: 0
+  });
+});
+Cypress.Commands.add("typeAndEnter", function (selector, text) {
+  cy.get(selector).clear().type("".concat(text, "{enter}"));
+});
+Cypress.Commands.add("verifyToastMessage", function (message) {
+  cy.get(commonSelectors.toastMessage).should("be.visible").should("have.text", message);
+
+  // close toast message
+  cy.get(commonSelectors.toastCloseButton).click();
+  cy.get(commonSelectors.toastMessage).should("not.exist");
+});
+Cypress.Commands.add("continueOnAlert", function (args) {
+  var props = _typeof$1(args) === "object" ? args : {
+    alias: args
+  };
+  var alias = props.alias,
+    title = props.title,
+    description = props.description,
+    _props$requestCount = props.requestCount,
+    requestCount = _props$requestCount === void 0 ? 1 : _props$requestCount,
+    toastMessage = props.toastMessage;
+  var hasMoreThanOneRequest = requestCount > 1;
+  title && cy.get(commonSelectors.alertTitle).should("have.text", title);
+  description && cy.get(commonSelectors.alertModalMessage).should("have.text", description);
+  cy.interceptApi(alias, requestCount);
+  cy.get(commonSelectors.alertModalSubmitButton).click();
+  cy.wait("@".concat(alias));
+  toastMessage && cy.verifyToastMessage(toastMessage);
+  hasMoreThanOneRequest && cy.waitForMultipleRequest("@".concat(alias), requestCount - 1);
+});
+Cypress.Commands.add("interceptApi", function (alias) {
+  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  return cy.intercept({
+    url: requestApis.allPath,
+    times: times
+  }).as(alias);
+});
+Cypress.Commands.add("waitForMultipleRequest", function (alias) {
+  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  return cy.wrap(_toConsumableArray(new Array(times))).each(function () {
+    return cy.wait(alias);
+  });
+});
+Cypress.Commands.add("apiRequest", function (options) {
+  return cy.get("@requestHeaders").then(function (requestHeaders) {
+    return requestHeaders ? cy.request(_objectSpread(_objectSpread({}, options), {}, {
+      headers: requestHeaders
+    })) : cy.log("No request headers found");
+  });
+});
+Cypress.Commands.add("reloadAndWait", function () {
+  var requestCount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  if (requestCount > 0) {
+    cy.interceptApi("reloadAllRequests", requestCount);
+    cy.reload();
+    cy.waitForMultipleRequest("@reloadAllRequests", requestCount);
+  }
+});
+Cypress.Commands.add("selectOption", function (containerSelector, optionText) {
+  cy.openInSameTabOnClick;
+  cy.get(containerSelector).click().type(optionText);
+  cy.contains(commonSelectors.selectOption, optionText).invoke("click");
+});
+Cypress.Commands.add("clickDropdownOption", function (optionText) {
+  var dropdownSelector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : commonSelectors.dropdownIcon;
+  cy.get(dropdownSelector).click();
+  cy.get(commonSelectors.dropdownContainer).contains(optionText).invoke("click");
+});
+Cypress.Commands.add("getText", function (selector) {
+  return cy.get(selector).invoke("text");
+});
+Cypress.Commands.add("getValue", function (selector) {
+  return cy.get(selector).invoke("val");
+});
+Cypress.Commands.add("getIframe", function (iframeSelector) {
+  return cy.get(iframeSelector).its("0.contentDocument.body").should("not.be.empty");
+});
+Cypress.Commands.add("openInSameTabOnClick", function (_ref) {
+  var url = _ref.url,
+    alias = _ref.alias,
+    selector = _ref.selector;
+  cy.window().then(function (win) {
+    cy.stub(win, "open").as(alias).callsFake(function (newUrl) {
+      return win.location.href = newUrl;
+    });
+  });
+  cy.get(selector).click();
+  cy.get("@".concat(alias)).should("be.called");
+  cy.url().should("include", url);
+});
+Cypress.Commands.add("globalState", function (key) {
+  return cy.task("getGlobalState", key);
+});
+
+var loginSelectors = {
+  appleAuthenticationButton: dataCy("apple-authentication-button"),
+  emailTextField: dataCy("login-email-text-field"),
+  googleAuthenticationButton: dataCy("google-authentication-button"),
+  githubAuthenticationButton: dataCy("github-authentication-button"),
+  loginViaEmailButton: dataCy("login-via-email-button"),
+  otpField: dataCy("otpinput-otp-number"),
+  passwordTextField: dataCy("login-password-text-field"),
+  rememberMeCheckBox: dataCy("login-remember-me-check-box"),
+  submitButton: dataCy("login-submit-button"),
+  twitterAuthenticationButton: dataCy("twitter-authentication-button")
+};
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+var regeneratorRuntime$1 = {exports: {}};
+
+var _typeof = {exports: {}};
+
+(function (module) {
+	function _typeof(obj) {
+	  "@babel/helpers - typeof";
+
+	  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+	    return typeof obj;
+	  } : function (obj) {
+	    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+	  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
+	}
+	module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (_typeof));
+
+(function (module) {
+	var _typeof$1 = _typeof.exports["default"];
+	function _regeneratorRuntime() {
+	  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
+	    return exports;
+	  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	  var exports = {},
+	    Op = Object.prototype,
+	    hasOwn = Op.hasOwnProperty,
+	    defineProperty = Object.defineProperty || function (obj, key, desc) {
+	      obj[key] = desc.value;
+	    },
+	    $Symbol = "function" == typeof Symbol ? Symbol : {},
+	    iteratorSymbol = $Symbol.iterator || "@@iterator",
+	    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+	    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+	  function define(obj, key, value) {
+	    return Object.defineProperty(obj, key, {
+	      value: value,
+	      enumerable: !0,
+	      configurable: !0,
+	      writable: !0
+	    }), obj[key];
+	  }
+	  try {
+	    define({}, "");
+	  } catch (err) {
+	    define = function define(obj, key, value) {
+	      return obj[key] = value;
+	    };
+	  }
+	  function wrap(innerFn, outerFn, self, tryLocsList) {
+	    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+	      generator = Object.create(protoGenerator.prototype),
+	      context = new Context(tryLocsList || []);
+	    return defineProperty(generator, "_invoke", {
+	      value: makeInvokeMethod(innerFn, self, context)
+	    }), generator;
+	  }
+	  function tryCatch(fn, obj, arg) {
+	    try {
+	      return {
+	        type: "normal",
+	        arg: fn.call(obj, arg)
+	      };
+	    } catch (err) {
+	      return {
+	        type: "throw",
+	        arg: err
+	      };
+	    }
+	  }
+	  exports.wrap = wrap;
+	  var ContinueSentinel = {};
+	  function Generator() {}
+	  function GeneratorFunction() {}
+	  function GeneratorFunctionPrototype() {}
+	  var IteratorPrototype = {};
+	  define(IteratorPrototype, iteratorSymbol, function () {
+	    return this;
+	  });
+	  var getProto = Object.getPrototypeOf,
+	    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+	  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+	  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+	  function defineIteratorMethods(prototype) {
+	    ["next", "throw", "return"].forEach(function (method) {
+	      define(prototype, method, function (arg) {
+	        return this._invoke(method, arg);
+	      });
+	    });
+	  }
+	  function AsyncIterator(generator, PromiseImpl) {
+	    function invoke(method, arg, resolve, reject) {
+	      var record = tryCatch(generator[method], generator, arg);
+	      if ("throw" !== record.type) {
+	        var result = record.arg,
+	          value = result.value;
+	        return value && "object" == _typeof$1(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+	          invoke("next", value, resolve, reject);
+	        }, function (err) {
+	          invoke("throw", err, resolve, reject);
+	        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+	          result.value = unwrapped, resolve(result);
+	        }, function (error) {
+	          return invoke("throw", error, resolve, reject);
+	        });
+	      }
+	      reject(record.arg);
+	    }
+	    var previousPromise;
+	    defineProperty(this, "_invoke", {
+	      value: function value(method, arg) {
+	        function callInvokeWithMethodAndArg() {
+	          return new PromiseImpl(function (resolve, reject) {
+	            invoke(method, arg, resolve, reject);
+	          });
+	        }
+	        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+	      }
+	    });
+	  }
+	  function makeInvokeMethod(innerFn, self, context) {
+	    var state = "suspendedStart";
+	    return function (method, arg) {
+	      if ("executing" === state) throw new Error("Generator is already running");
+	      if ("completed" === state) {
+	        if ("throw" === method) throw arg;
+	        return doneResult();
+	      }
+	      for (context.method = method, context.arg = arg;;) {
+	        var delegate = context.delegate;
+	        if (delegate) {
+	          var delegateResult = maybeInvokeDelegate(delegate, context);
+	          if (delegateResult) {
+	            if (delegateResult === ContinueSentinel) continue;
+	            return delegateResult;
+	          }
+	        }
+	        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+	          if ("suspendedStart" === state) throw state = "completed", context.arg;
+	          context.dispatchException(context.arg);
+	        } else "return" === context.method && context.abrupt("return", context.arg);
+	        state = "executing";
+	        var record = tryCatch(innerFn, self, context);
+	        if ("normal" === record.type) {
+	          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+	          return {
+	            value: record.arg,
+	            done: context.done
+	          };
+	        }
+	        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+	      }
+	    };
+	  }
+	  function maybeInvokeDelegate(delegate, context) {
+	    var methodName = context.method,
+	      method = delegate.iterator[methodName];
+	    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
+	    var record = tryCatch(method, delegate.iterator, context.arg);
+	    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+	    var info = record.arg;
+	    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+	  }
+	  function pushTryEntry(locs) {
+	    var entry = {
+	      tryLoc: locs[0]
+	    };
+	    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+	  }
+	  function resetTryEntry(entry) {
+	    var record = entry.completion || {};
+	    record.type = "normal", delete record.arg, entry.completion = record;
+	  }
+	  function Context(tryLocsList) {
+	    this.tryEntries = [{
+	      tryLoc: "root"
+	    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+	  }
+	  function values(iterable) {
+	    if (iterable) {
+	      var iteratorMethod = iterable[iteratorSymbol];
+	      if (iteratorMethod) return iteratorMethod.call(iterable);
+	      if ("function" == typeof iterable.next) return iterable;
+	      if (!isNaN(iterable.length)) {
+	        var i = -1,
+	          next = function next() {
+	            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+	            return next.value = undefined, next.done = !0, next;
+	          };
+	        return next.next = next;
+	      }
+	    }
+	    return {
+	      next: doneResult
+	    };
+	  }
+	  function doneResult() {
+	    return {
+	      value: undefined,
+	      done: !0
+	    };
+	  }
+	  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+	    value: GeneratorFunctionPrototype,
+	    configurable: !0
+	  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+	    value: GeneratorFunction,
+	    configurable: !0
+	  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+	    var ctor = "function" == typeof genFun && genFun.constructor;
+	    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+	  }, exports.mark = function (genFun) {
+	    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+	  }, exports.awrap = function (arg) {
+	    return {
+	      __await: arg
+	    };
+	  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+	    return this;
+	  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+	    void 0 === PromiseImpl && (PromiseImpl = Promise);
+	    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+	    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+	      return result.done ? result.value : iter.next();
+	    });
+	  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+	    return this;
+	  }), define(Gp, "toString", function () {
+	    return "[object Generator]";
+	  }), exports.keys = function (val) {
+	    var object = Object(val),
+	      keys = [];
+	    for (var key in object) keys.push(key);
+	    return keys.reverse(), function next() {
+	      for (; keys.length;) {
+	        var key = keys.pop();
+	        if (key in object) return next.value = key, next.done = !1, next;
+	      }
+	      return next.done = !0, next;
+	    };
+	  }, exports.values = values, Context.prototype = {
+	    constructor: Context,
+	    reset: function reset(skipTempReset) {
+	      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+	    },
+	    stop: function stop() {
+	      this.done = !0;
+	      var rootRecord = this.tryEntries[0].completion;
+	      if ("throw" === rootRecord.type) throw rootRecord.arg;
+	      return this.rval;
+	    },
+	    dispatchException: function dispatchException(exception) {
+	      if (this.done) throw exception;
+	      var context = this;
+	      function handle(loc, caught) {
+	        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+	      }
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i],
+	          record = entry.completion;
+	        if ("root" === entry.tryLoc) return handle("end");
+	        if (entry.tryLoc <= this.prev) {
+	          var hasCatch = hasOwn.call(entry, "catchLoc"),
+	            hasFinally = hasOwn.call(entry, "finallyLoc");
+	          if (hasCatch && hasFinally) {
+	            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+	            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+	          } else if (hasCatch) {
+	            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+	          } else {
+	            if (!hasFinally) throw new Error("try statement without catch or finally");
+	            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+	          }
+	        }
+	      }
+	    },
+	    abrupt: function abrupt(type, arg) {
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i];
+	        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+	          var finallyEntry = entry;
+	          break;
+	        }
+	      }
+	      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+	      var record = finallyEntry ? finallyEntry.completion : {};
+	      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+	    },
+	    complete: function complete(record, afterLoc) {
+	      if ("throw" === record.type) throw record.arg;
+	      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+	    },
+	    finish: function finish(finallyLoc) {
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i];
+	        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+	      }
+	    },
+	    "catch": function _catch(tryLoc) {
+	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+	        var entry = this.tryEntries[i];
+	        if (entry.tryLoc === tryLoc) {
+	          var record = entry.completion;
+	          if ("throw" === record.type) {
+	            var thrown = record.arg;
+	            resetTryEntry(entry);
+	          }
+	          return thrown;
+	        }
+	      }
+	      throw new Error("illegal catch attempt");
+	    },
+	    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+	      return this.delegate = {
+	        iterator: values(iterable),
+	        resultName: resultName,
+	        nextLoc: nextLoc
+	      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+	    }
+	  }, exports;
+	}
+	module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (regeneratorRuntime$1));
+
+// TODO(Babel 8): Remove this file.
+
+var runtime = regeneratorRuntime$1.exports();
+
+// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  if (typeof globalThis === "object") {
+    globalThis.regeneratorRuntime = runtime;
+  } else {
+    Function("r", "regeneratorRuntime = r")(runtime);
+  }
+}
+
+/**
+ * @template {Function} T
+ * @param {T} func
+ * @returns {T}
+ */
+var nullSafe = function nullSafe(func) {
+  return (
+    // @ts-ignore
+    ramda.curryN(func.length, function () {
+      var _ref;
+      var dataArg = (_ref = func.length - 1, _ref < 0 || arguments.length <= _ref ? undefined : arguments[_ref]);
+      return ramda.isNil(dataArg) ? dataArg : func.apply(void 0, arguments);
+    })
+  );
+};
+
+var slugify = function slugify(string) {
+  return string.toString().toLowerCase().replace(/\s+/g, "-") // Replace spaces with -
+  .replace(/&/g, "-and-") // Replace & with 'and'
+  .replace(/[^\w-]+/g, "") // Remove all non-word characters
+  .replace(/--+/g, "-") // Replace multiple - with single -
+  .replace(/^-+/, "") // Trim - from start of text
+  .replace(/-+$/, "");
+}; // Trim - from end of text
+
+var humanize = function humanize(string) {
+  string = string.replace(/[_-]+/g, " ").replace(/\s{2,}/g, " ").replace(/([a-z\d])([A-Z])/g, "$1" + " " + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + " " + "$2").toLowerCase().trim();
+  string = string.charAt(0).toUpperCase() + string.slice(1);
+  return string;
+};
+var snakeToCamelCase = function snakeToCamelCase(string) {
+  return string.replace(/(_\w)/g, function (letter) {
+    return letter[1].toUpperCase();
+  });
+};
+var camelToSnakeCase = function camelToSnakeCase(string) {
+  return string.replace(/[A-Z]/g, function (letter) {
+    return "_".concat(letter.toLowerCase());
+  });
+};
+var capitalize = function capitalize(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+nullSafe(slugify);
+nullSafe(humanize);
+nullSafe(snakeToCamelCase);
+nullSafe(camelToSnakeCase);
+nullSafe(capitalize);
+
+var filterNonNull = function filterNonNull(object) {
+  return Object.fromEntries(Object.entries(object).filter(function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+      v = _ref6[1];
+    return !ramda.isNil(v);
+  }).map(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+      k = _ref8[0],
+      v = _ref8[1];
+    return [k, _typeof$1(v) === "object" && !Array.isArray(v) ? filterNonNull(v) : v];
+  }));
+};
+nullSafe(filterNonNull);
+
+/* eslint complexity: [2, 18], max-statements: [2, 33] */
+var shams = function hasSymbols() {
+	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+	if (typeof Symbol.iterator === 'symbol') { return true; }
+
+	var obj = {};
+	var sym = Symbol('test');
+	var symObj = Object(sym);
+	if (typeof sym === 'string') { return false; }
+
+	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+	// temp disabled per https://github.com/ljharb/object.assign/issues/17
+	// if (sym instanceof Symbol) { return false; }
+	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+	// if (!(symObj instanceof Symbol)) { return false; }
+
+	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+	var symVal = 42;
+	obj[sym] = symVal;
+	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
+
+	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
+
+	var syms = Object.getOwnPropertySymbols(obj);
+	if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+	if (typeof Object.getOwnPropertyDescriptor === 'function') {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+	}
+
+	return true;
+};
+
+var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+var hasSymbolSham = shams;
+
+var hasSymbols$1 = function hasNativeSymbols() {
+	if (typeof origSymbol !== 'function') { return false; }
+	if (typeof Symbol !== 'function') { return false; }
+	if (typeof origSymbol('foo') !== 'symbol') { return false; }
+	if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+	return hasSymbolSham();
+};
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var slice = Array.prototype.slice;
+var toStr = Object.prototype.toString;
+var funcType = '[object Function]';
+
+var implementation$1 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slice.call(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                args.concat(slice.call(arguments))
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        } else {
+            return target.apply(
+                that,
+                args.concat(slice.call(arguments))
+            );
+        }
+    };
+
+    var boundLength = Math.max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs.push('$' + i);
+    }
+
+    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};
+
+var implementation = implementation$1;
+
+var functionBind = Function.prototype.bind || implementation;
+
+var bind$1 = functionBind;
+
+var src = bind$1.call(Function.call, Object.prototype.hasOwnProperty);
+
+var undefined$1;
+
+var $SyntaxError = SyntaxError;
+var $Function = Function;
+var $TypeError = TypeError;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+	try {
+		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+	} catch (e) {}
+};
+
+var $gOPD = Object.getOwnPropertyDescriptor;
+if ($gOPD) {
+	try {
+		$gOPD({}, '');
+	} catch (e) {
+		$gOPD = null; // this is IE 8, which has a broken gOPD
+	}
+}
+
+var throwTypeError = function () {
+	throw new $TypeError();
+};
+var ThrowTypeError = $gOPD
+	? (function () {
+		try {
+			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+			arguments.callee; // IE 8 does not throw here
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}())
+	: throwTypeError;
+
+var hasSymbols = hasSymbols$1();
+
+var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
+
+var needsEval = {};
+
+var TypedArray = typeof Uint8Array === 'undefined' ? undefined$1 : getProto(Uint8Array);
+
+var INTRINSICS = {
+	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
+	'%Array%': Array,
+	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+	'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined$1,
+	'%AsyncFromSyncIteratorPrototype%': undefined$1,
+	'%AsyncFunction%': needsEval,
+	'%AsyncGenerator%': needsEval,
+	'%AsyncGeneratorFunction%': needsEval,
+	'%AsyncIteratorPrototype%': needsEval,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+	'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
+	'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
+	'%Boolean%': Boolean,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%Date%': Date,
+	'%decodeURI%': decodeURI,
+	'%decodeURIComponent%': decodeURIComponent,
+	'%encodeURI%': encodeURI,
+	'%encodeURIComponent%': encodeURIComponent,
+	'%Error%': Error,
+	'%eval%': eval, // eslint-disable-line no-eval
+	'%EvalError%': EvalError,
+	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+	'%Math%': Math,
+	'%Number%': Number,
+	'%Object%': Object,
+	'%parseFloat%': parseFloat,
+	'%parseInt%': parseInt,
+	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+	'%RangeError%': RangeError,
+	'%ReferenceError%': ReferenceError,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+	'%RegExp%': RegExp,
+	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined$1,
+	'%Symbol%': hasSymbols ? Symbol : undefined$1,
+	'%SyntaxError%': $SyntaxError,
+	'%ThrowTypeError%': ThrowTypeError,
+	'%TypedArray%': TypedArray,
+	'%TypeError%': $TypeError,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%URIError%': URIError,
+	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
+	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
+};
+
+try {
+	null.error; // eslint-disable-line no-unused-expressions
+} catch (e) {
+	// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+	var errorProto = getProto(getProto(e));
+	INTRINSICS['%Error.prototype%'] = errorProto;
+}
+
+var doEval = function doEval(name) {
+	var value;
+	if (name === '%AsyncFunction%') {
+		value = getEvalledConstructor('async function () {}');
+	} else if (name === '%GeneratorFunction%') {
+		value = getEvalledConstructor('function* () {}');
+	} else if (name === '%AsyncGeneratorFunction%') {
+		value = getEvalledConstructor('async function* () {}');
+	} else if (name === '%AsyncGenerator%') {
+		var fn = doEval('%AsyncGeneratorFunction%');
+		if (fn) {
+			value = fn.prototype;
+		}
+	} else if (name === '%AsyncIteratorPrototype%') {
+		var gen = doEval('%AsyncGenerator%');
+		if (gen) {
+			value = getProto(gen.prototype);
+		}
+	}
+
+	INTRINSICS[name] = value;
+
+	return value;
+};
+
+var LEGACY_ALIASES = {
+	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+	'%ArrayPrototype%': ['Array', 'prototype'],
+	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
+	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+	'%BooleanPrototype%': ['Boolean', 'prototype'],
+	'%DataViewPrototype%': ['DataView', 'prototype'],
+	'%DatePrototype%': ['Date', 'prototype'],
+	'%ErrorPrototype%': ['Error', 'prototype'],
+	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
+	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+	'%FunctionPrototype%': ['Function', 'prototype'],
+	'%Generator%': ['GeneratorFunction', 'prototype'],
+	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+	'%JSONParse%': ['JSON', 'parse'],
+	'%JSONStringify%': ['JSON', 'stringify'],
+	'%MapPrototype%': ['Map', 'prototype'],
+	'%NumberPrototype%': ['Number', 'prototype'],
+	'%ObjectPrototype%': ['Object', 'prototype'],
+	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+	'%PromisePrototype%': ['Promise', 'prototype'],
+	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+	'%Promise_all%': ['Promise', 'all'],
+	'%Promise_reject%': ['Promise', 'reject'],
+	'%Promise_resolve%': ['Promise', 'resolve'],
+	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
+	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+	'%RegExpPrototype%': ['RegExp', 'prototype'],
+	'%SetPrototype%': ['Set', 'prototype'],
+	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+	'%StringPrototype%': ['String', 'prototype'],
+	'%SymbolPrototype%': ['Symbol', 'prototype'],
+	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
+	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+	'%URIErrorPrototype%': ['URIError', 'prototype'],
+	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
+	'%WeakSetPrototype%': ['WeakSet', 'prototype']
+};
+
+var bind = functionBind;
+var hasOwn = src;
+var $concat = bind.call(Function.call, Array.prototype.concat);
+var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+var $replace = bind.call(Function.call, String.prototype.replace);
+var $strSlice = bind.call(Function.call, String.prototype.slice);
+var $exec = bind.call(Function.call, RegExp.prototype.exec);
+
+/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+var stringToPath = function stringToPath(string) {
+	var first = $strSlice(string, 0, 1);
+	var last = $strSlice(string, -1);
+	if (first === '%' && last !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
+	} else if (last === '%' && first !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
+	}
+	var result = [];
+	$replace(string, rePropName, function (match, number, quote, subString) {
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+	});
+	return result;
+};
+/* end adaptation */
+
+var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+	var intrinsicName = name;
+	var alias;
+	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+		alias = LEGACY_ALIASES[intrinsicName];
+		intrinsicName = '%' + alias[0] + '%';
+	}
+
+	if (hasOwn(INTRINSICS, intrinsicName)) {
+		var value = INTRINSICS[intrinsicName];
+		if (value === needsEval) {
+			value = doEval(intrinsicName);
+		}
+		if (typeof value === 'undefined' && !allowMissing) {
+			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		}
+
+		return {
+			alias: alias,
+			name: intrinsicName,
+			value: value
+		};
+	}
+
+	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
+};
+
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new $TypeError('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+		throw new $TypeError('"allowMissing" argument must be a boolean');
+	}
+
+	if ($exec(/^%?[^%]*%?$/, name) === null) {
+		throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+	}
+	var parts = stringToPath(name);
+	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
+
+	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
+	var intrinsicRealName = intrinsic.name;
+	var value = intrinsic.value;
+	var skipFurtherCaching = false;
+
+	var alias = intrinsic.alias;
+	if (alias) {
+		intrinsicBaseName = alias[0];
+		$spliceApply(parts, $concat([0, 1], alias));
+	}
+
+	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+		var part = parts[i];
+		var first = $strSlice(part, 0, 1);
+		var last = $strSlice(part, -1);
+		if (
+			(
+				(first === '"' || first === "'" || first === '`')
+				|| (last === '"' || last === "'" || last === '`')
+			)
+			&& first !== last
+		) {
+			throw new $SyntaxError('property names with quotes must have matching quotes');
+		}
+		if (part === 'constructor' || !isOwn) {
+			skipFurtherCaching = true;
+		}
+
+		intrinsicBaseName += '.' + part;
+		intrinsicRealName = '%' + intrinsicBaseName + '%';
+
+		if (hasOwn(INTRINSICS, intrinsicRealName)) {
+			value = INTRINSICS[intrinsicRealName];
+		} else if (value != null) {
+			if (!(part in value)) {
+				if (!allowMissing) {
+					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				return void undefined$1;
+			}
+			if ($gOPD && (i + 1) >= parts.length) {
+				var desc = $gOPD(value, part);
+				isOwn = !!desc;
+
+				// By convention, when a data property is converted to an accessor
+				// property to emulate a data property that does not suffer from
+				// the override mistake, that accessor's getter is marked with
+				// an `originalValue` property. Here, when we detect this, we
+				// uphold the illusion by pretending to see that original data
+				// property, i.e., returning the value rather than the getter
+				// itself.
+				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+					value = desc.get;
+				} else {
+					value = value[part];
+				}
+			} else {
+				isOwn = hasOwn(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+	}
+	return value;
+};
+
+var callBind$1 = {exports: {}};
+
+(function (module) {
+
+	var bind = functionBind;
+	var GetIntrinsic = getIntrinsic;
+
+	var $apply = GetIntrinsic('%Function.prototype.apply%');
+	var $call = GetIntrinsic('%Function.prototype.call%');
+	var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
+
+	var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
+	var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+	var $max = GetIntrinsic('%Math.max%');
+
+	if ($defineProperty) {
+		try {
+			$defineProperty({}, 'a', { value: 1 });
+		} catch (e) {
+			// IE 8 has a broken defineProperty
+			$defineProperty = null;
+		}
+	}
+
+	module.exports = function callBind(originalFunction) {
+		var func = $reflectApply(bind, $call, arguments);
+		if ($gOPD && $defineProperty) {
+			var desc = $gOPD(func, 'length');
+			if (desc.configurable) {
+				// original length, plus the receiver, minus any additional arguments (after the receiver)
+				$defineProperty(
+					func,
+					'length',
+					{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
+				);
+			}
+		}
+		return func;
+	};
+
+	var applyBind = function applyBind() {
+		return $reflectApply(bind, $apply, arguments);
+	};
+
+	if ($defineProperty) {
+		$defineProperty(module.exports, 'apply', { value: applyBind });
+	} else {
+		module.exports.apply = applyBind;
+	}
+} (callBind$1));
+
+var GetIntrinsic$1 = getIntrinsic;
+
+var callBind = callBind$1.exports;
+
+var $indexOf = callBind(GetIntrinsic$1('String.prototype.indexOf'));
+
+var callBound$1 = function callBoundIntrinsic(name, allowMissing) {
+	var intrinsic = GetIntrinsic$1(name, !!allowMissing);
+	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+		return callBind(intrinsic);
+	}
+	return intrinsic;
+};
+
+var GetIntrinsic = getIntrinsic;
+var callBound = callBound$1;
+
+GetIntrinsic('%TypeError%');
+GetIntrinsic('%WeakMap%', true);
+GetIntrinsic('%Map%', true);
+
+callBound('WeakMap.prototype.get', true);
+callBound('WeakMap.prototype.set', true);
+callBound('WeakMap.prototype.has', true);
+callBound('Map.prototype.get', true);
+callBound('Map.prototype.set', true);
+callBound('Map.prototype.has', true);
+
+((function () {
+    var array = [];
+    for (var i = 0; i < 256; ++i) {
+        array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+    }
+
+    return array;
+})());
+
+var joinHyphenCase = function joinHyphenCase() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return args.join(" ").replace(/\s+/g, "-").toLowerCase();
+};
+
+var memberSelectors = {
+  membersTab: common.dataCy("agent-nav-tab"),
+  newButton: common.dataCy("ntm-add-member-button"),
+  continueButton: common.dataCy("ntm-manage-member-continue-button"),
+  submitButton: common.dataCy("ntm-manage-member-submit-button"),
+  searchTextField: common.dataCy("ntm-search-members-input"),
+  email: "td:nth-child(3)",
+  role: "td:nth-child(4)",
+  deactivatedAgentsButton: common.dataCy("ntm-members-menubar-deactivated-block"),
+  activatedMembersButton: common.dataCy("ntm-members-menubar-active-block"),
+  columnCheckBox: common.dataCy("neeto-ui-columns-checkbox"),
+  roleLabel: function roleLabel(role) {
+    return common.dataCy("".concat(joinHyphenCase(role), "-radio-label"));
+  },
+  dropDownIcon: common.dataCy("ntm-members-table-row-dropdown-button"),
+  menuBarHeading: common.dataCy("ntm-members-menubar-heading")
+};
+var memberFormSelectors = {
+  emailTextField: "input.neeto-ui-react-select__input:eq(0)"
+};
+
+var signUpSelectors = {
+  emailTextField: dataCy("signup-email-text-field"),
+  firstNameTextField: dataCy("signup-profile-first-name-text-field"),
+  lastNameTextField: dataCy("signup-profile-last-name-text-field"),
+  organizationNameTextField: dataCy("signup-organization-name-text-field"),
+  organizationSubmitButton: dataCy("signup-organization-submit-button"),
+  otpTextBox: dataCy("otpinput-otp-number"),
+  profileSubmitButton: dataCy("signup-profile-submit-button"),
+  signupViaEmailButton: dataCy("signup-via-email-button"),
+  submitButton: dataCy("signup-email-submit-button"),
+  subdomainNameTextField: dataCy("signup-organization-subdomain-text-field")
+};
+
+var commonTexts = {
+  activate: "Activate",
+  block: "Block",
+  copiedToClipboard: "Copied to clipboard!",
+  crossSiteScript: "<script>alert('XSS')</script>",
+  deactivate: "Deactivate",
+  "delete": "Delete",
+  edit: "Edit",
+  invalidEmailMessage: "Please enter a valid email.",
+  invalidSearchInput: "Invalid search input",
+  logout: "Log out",
+  "new": "New",
+  takeAction: "Take action",
+  unblock: "Unblock"
+};
+
+var memberTexts = {
+  addMember: "Add new member",
+  admin: "Admin",
+  agent: "Agent",
+  agents: "Agents",
+  activeMembersHeading: "Active members",
+  accountActivatedToastMessage: function accountActivatedToastMessage(name) {
+    return "".concat(name, "'s account has been activated.");
+  },
+  activateMember: "Activate member",
+  activateMemberAlertMessage: function activateMemberAlertMessage(email) {
+    return "You are activating ".concat(email, ". Are you sure you want to proceed?");
+  },
+  addMemberToProducts: function addMemberToProducts(email) {
+    return "Add ".concat(email, " to the following neeto products.");
+  },
+  deactivateAccountToastMessage: function deactivateAccountToastMessage(name) {
+    return "".concat(name, "'s account has been deactivated.");
+  },
+  deactivateMember: "Deactivate member",
+  deactivateMemberAlertMessage: function deactivateMemberAlertMessage(email) {
+    return "You are deactivating ".concat(email, ". Are you sure you want to proceed?");
+  },
+  editMember: "Edit member",
+  inviteMessage: function inviteMessage(_ref) {
+    var email = _ref.email,
+      role = _ref.role,
+      appName = _ref.appName;
+    return "".concat(email, " will be invited to ").concat(appName, " with a role of ").concat(role, ".");
+  },
+  memberAddedMessage: "Added member successfully!",
+  members: "Members",
+  newHeading: "Add new member",
+  updatedMemberRole: function updatedMemberRole(email, role) {
+    return "Updated ".concat(email, "'s role to ").concat(role, ".");
+  }
+};
+var memberTableTexts = {
+  assignedTickets: "Assigned Tickets",
+  availabilityForDesk: "Availability for Desk",
+  created: "Created",
+  email: "Email",
+  name: "Name",
+  role: "Role",
+  teams: "Teams"
+};
+
+var signUpTexts = {
+  email: "Email",
+  profile: "profile",
+  tryItFree: "Try it FREE"
+};
+
+var verifySSOLoginPage = function verifySSOLoginPage() {
+  cy.log("verify Login Page");
+  cy.get(loginSelectors.githubAuthenticationButton).should("be.visible");
+  cy.get(loginSelectors.twitterAuthenticationButton).should("be.visible");
+  cy.get(loginSelectors.appleAuthenticationButton).should("be.visible");
+  cy.get(loginSelectors.googleAuthenticationButton).should("be.visible");
+  cy.log("verify Cross Site scripting");
+  cy.get(loginSelectors.loginViaEmailButton).click();
+  cy.clearAndType(loginSelectors.emailTextField, commonTexts.crossSiteScript);
+  cy.get(loginSelectors.submitButton).click();
+  cy.get(commonSelectors.windowAlert).should("not.exist");
+  cy.log("verify email login");
+  cy.get(commonSelectors.emailInputError).should("have.text", commonTexts.invalidEmailMessage);
+  cy.get(loginSelectors.emailTextField).clear();
+  cy.get(loginSelectors.submitButton).click();
+  cy.get(commonSelectors.emailInputError).should("have.text", commonTexts.invalidEmailMessage);
+};
+var logout = function logout(homeUrl) {
+  cy.get(profileSelectors.profileSidebar).click();
+  cy.get(profileSelectors.logoutLink).should("have.text", commonTexts.logout).invoke("click");
+  cy.url({
+    timeout: 15000
+  }).should("not.include", homeUrl);
+};
+var authUtils = {
+  verifySSOLoginPage: verifySSOLoginPage,
+  logout: logout
+};
+
+var currentDate = function currentDate() {
+  return dayjs__default["default"]().format("YYYY-MM-DD");
+};
+var futureDate = function futureDate() {
+  var numberOfDays = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+  var date = dayjs__default["default"]().add(numberOfDays, "day").format("YYYY-MM-DD");
+  return date;
+};
+var pastDate = function pastDate() {
+  var numberOfDays = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+  var date = dayjs__default["default"]().subtract(numberOfDays, "day").format("YYYY-MM-DD");
+  return date;
+};
+var dateUtils = {
+  currentDate: currentDate,
+  futureDate: futureDate,
+  pastDate: pastDate
+};
+
+var interceptMemberApi = function interceptMemberApi(alias) {
+  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  return cy.intercept({
+    url: requestApis.teamMembers.all,
+    times: times
+  }).as(alias);
+};
+var navigateToMembersPage = function navigateToMembersPage() {
+  var waitForRequest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  waitForRequest && interceptMemberApi("fetchMembers", 2);
+  cy.get(memberSelectors.membersTab).click();
+  cy.url().should("include", urlPaths.members);
+  waitForRequest && cy.waitForMultipleRequest("@fetchMembers", 2);
+  cy.get(commonSelectors.heading).should("have.text", memberTexts.activeMembersHeading);
+};
+var addMemberViaUI = function addMemberViaUI(email) {
+  var role = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : memberTexts.agent;
+  cy.get(memberSelectors.newButton).should("have.text", memberTexts.addMember).click();
+  cy.get(commonSelectors.paneHeader).should("have.text", memberTexts.newHeading);
+  cy.get(memberFormSelectors.emailTextField).should("be.focused");
+  cy.typeAndEnter(memberFormSelectors.emailTextField, email);
+  cy.get(memberSelectors.roleLabel(role)).click();
+  cy.get(memberSelectors.continueButton).click();
+  if (isStagingEnv) {
+    cy.get(commonSelectors.checkboxLabel).should("have.text", memberTexts.addMemberToProducts(email));
+    cy.get(commonSelectors.paneBody).within(function () {
+      return cy.get(commonSelectors.checkbox).uncheck();
+    });
+    cy.get(memberSelectors.continueButton).click();
+  }
+  cy.get(commonSelectors.paneBody).should("contain.text", memberTexts.inviteMessage({
+    email: email,
+    role: role,
+    appName: "neetoDesk"
+  }));
+  interceptMemberApi("createAndFetchMember", 2);
+  cy.get(memberSelectors.submitButton).click();
+  cy.wait("@createAndFetchMember");
+  cy.verifyToastMessage(memberTexts.memberAddedMessage);
+  cy.wait("@createAndFetchMember");
+  cy.clearAndType(memberSelectors.searchTextField, email);
+  interceptMemberApi("searchRequest");
+  cy.clearAndType(memberSelectors.searchTextField, email);
+  cy.wait("@searchRequest");
+  cy.contains(tableSelectors.tableRow, email).should("be.visible");
+};
+var verifyMemberDetails = function verifyMemberDetails(_ref) {
+  var email = _ref.email,
+    role = _ref.role,
+    _ref$skipSearchReques = _ref.skipSearchRequest,
+    skipSearchRequest = _ref$skipSearchReques === void 0 ? true : _ref$skipSearchReques;
+  !skipSearchRequest && interceptMemberApi("searchRequest");
+  cy.clearAndTypeFast(memberSelectors.searchTextField, email);
+  !skipSearchRequest && cy.wait("@searchRequest");
+  return cy.contains(commonSelectors.tableRow, email).within(function () {
+    cy.get(memberSelectors.email).should("have.text", email);
+    role && cy.get(memberSelectors.role).should("have.text", role);
+  });
+};
+var updateMemberRole = function updateMemberRole(_ref2) {
+  var email = _ref2.email,
+    role = _ref2.role,
+    skipSearchRequest = _ref2.skipSearchRequest;
+  verifyMemberDetails({
+    email: email,
+    skipSearchRequest: skipSearchRequest
+  }).within(function () {
+    return cy.clickDropdownOption(commonTexts.edit);
+  });
+  cy.get(commonSelectors.paneHeader).should("have.text", memberTexts.updateMemberRole);
+  cy.get(memberSelectors.roleLabel(role)).click();
+  interceptMemberApi("updateAndFetchMember", 2);
+  cy.get(memberSelectors.submitButton).click();
+  cy.wait("@updateAndFetchMember");
+  cy.verifyToastMessage(memberTexts.updatedMemberRole(email, role.toLocaleLowerCase()));
+  cy.wait("@updateAndFetchMember");
+  verifyMemberDetails({
+    email: email,
+    role: role
+  });
+};
+var verifyActivatedMember = function verifyActivatedMember(_ref3) {
+  var email = _ref3.email,
+    _ref3$skipFetchReques = _ref3.skipFetchRequest,
+    skipFetchRequest = _ref3$skipFetchReques === void 0 ? false : _ref3$skipFetchReques,
+    _ref3$skipSearchReque = _ref3.skipSearchRequest,
+    skipSearchRequest = _ref3$skipSearchReque === void 0 ? true : _ref3$skipSearchReque;
+  cy.get(commonSelectors.toggleButton).click();
+  cy.get(memberSelectors.menuBarHeading).should("have.text", memberTexts.members);
+  !skipFetchRequest && interceptMemberApi("fetchActivatedMembers");
+  cy.get(memberSelectors.activatedMembersButton).click();
+  !skipFetchRequest && cy.wait("@fetchActivatedMembers");
+  verifyMemberDetails({
+    email: email,
+    skipSearchRequest: skipSearchRequest
+  });
+  cy.get(commonSelectors.toggleButton).click();
+};
+var verifyDeactivatedMember = function verifyDeactivatedMember(_ref4) {
+  var email = _ref4.email,
+    _ref4$skipFetchReques = _ref4.skipFetchRequest,
+    skipFetchRequest = _ref4$skipFetchReques === void 0 ? false : _ref4$skipFetchReques,
+    _ref4$skipSearchReque = _ref4.skipSearchRequest,
+    skipSearchRequest = _ref4$skipSearchReque === void 0 ? true : _ref4$skipSearchReque;
+  cy.get(commonSelectors.toggleButton).click();
+  cy.get(memberSelectors.menuBarHeading).should("have.text", memberTexts.members);
+  !skipFetchRequest && interceptMemberApi("fetchDeactivatedMembers");
+  cy.get(memberSelectors.deactivatedAgentsButton).click();
+  !skipFetchRequest && cy.wait("@fetchDeactivatedMembers");
+  verifyMemberDetails({
+    email: email,
+    skipSearchRequest: skipSearchRequest
+  });
+  cy.get(commonSelectors.toggleButton).click();
+};
+var verifyActivateAlert = function verifyActivateAlert(email) {
+  var skipSearchRequest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  verifyMemberDetails({
+    email: email,
+    skipSearchRequest: skipSearchRequest
+  }).within(function () {
+    return cy.clickDropdownOption(commonTexts.activate);
+  });
+  cy.get(commonSelectors.alertTitle).should("have.text", memberTexts.activateMember);
+  cy.get(commonSelectors.alertModalMessage).should("have.text", memberTexts.activateMemberAlertMessage(email));
+};
+var deactivateMember = function deactivateMember(_ref5) {
+  var email = _ref5.email,
+    _ref5$skipSearchReque = _ref5.skipSearchRequest,
+    skipSearchRequest = _ref5$skipSearchReque === void 0 ? true : _ref5$skipSearchReque;
+  verifyMemberDetails({
+    email: email,
+    skipSearchRequest: skipSearchRequest
+  }).within(function () {
+    return cy.clickDropdownOption(commonTexts.deactivate);
+  });
+  interceptMemberApi("deactivateAndFetchMember", 2);
+  cy.get(commonSelectors.alertModalSubmitButton).click();
+  cy.wait("@deactivateAndFetchMember");
+  cy.verifyToastMessage(memberTexts.deactivateAccountToastMessage(email));
+  cy.wait("@deactivateAndFetchMember");
+  verifyDeactivatedMember({
+    email: email
+  });
+};
+var activateMember = function activateMember(_ref6) {
+  var email = _ref6.email,
+    _ref6$skipSearchReque = _ref6.skipSearchRequest,
+    skipSearchRequest = _ref6$skipSearchReque === void 0 ? true : _ref6$skipSearchReque;
+  verifyActivateAlert(email, skipSearchRequest);
+  interceptMemberApi("activateAndFetchMember", 2);
+  cy.get(commonSelectors.alertModalSubmitButton).click();
+  cy.wait("@activateAndFetchMember");
+  cy.verifyToastMessage(memberTexts.accountActivatedToastMessage(email));
+  cy.wait("@activateAndFetchMember");
+  verifyActivatedMember({
+    email: email
+  });
+};
+var checkColumnCheckBox = function checkColumnCheckBox(fieldSelector) {
+  return cy.get(fieldSelector).parent().within(function () {
+    cy.get(memberSelectors.columnCheckBox).should("be.checked").uncheck().should("not.be.checked");
+  });
+};
+var unCheckColumnCheckBox = function unCheckColumnCheckBox(fieldSelector) {
+  return cy.get(fieldSelector).parent().within(function () {
+    cy.get(memberSelectors.columnCheckBox).should("not.be.checked").check().should("be.checked");
+  });
+};
+var addMemberViaRequest = function addMemberViaRequest(_ref7) {
+  var email = _ref7.email,
+    _ref7$role = _ref7.role,
+    role = _ref7$role === void 0 ? memberTexts.agent : _ref7$role,
+    _ref7$requestCount = _ref7.requestCount,
+    requestCount = _ref7$requestCount === void 0 ? 0 : _ref7$requestCount,
+    appName = _ref7.appName;
+  cy.apiRequest({
+    method: "POST",
+    url: requestApis.teamMembers.index,
+    body: {
+      user: {
+        emails: [email],
+        organization_role: role,
+        app_roles: [{
+          app_name: appName,
+          active_role: role,
+          is_enabled: true
+        }]
+      }
+    }
+  });
+  cy.reloadAndWait(requestCount);
+};
+var deactivateMemberViaRequest = function deactivateMemberViaRequest(email) {
+  var requestCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  cy.apiRequest({
+    method: "PATCH",
+    url: requestApis.teamMembers.bulkUpdate,
+    body: {
+      users: {
+        active: false,
+        emails: [email]
+      }
+    }
+  });
+  cy.reloadAndWait(requestCount);
+};
+var memberUtils = {
+  addMemberViaRequest: addMemberViaRequest,
+  addMemberViaUI: addMemberViaUI,
+  activateMember: activateMember,
+  checkColumnCheckBox: checkColumnCheckBox,
+  deactivateMember: deactivateMember,
+  deactivateMemberViaRequest: deactivateMemberViaRequest,
+  updateMemberRole: updateMemberRole,
+  interceptMemberApi: interceptMemberApi,
+  navigateToMembersPage: navigateToMembersPage,
+  unCheckColumnCheckBox: unCheckColumnCheckBox,
+  verifyMemberDetails: verifyMemberDetails
+};
+
+var createOrganization = function createOrganization(_ref) {
+  var email = _ref.email,
+    businessName = _ref.businessName,
+    subdomainName = _ref.subdomainName,
+    firstName = _ref.firstName,
+    lastName = _ref.lastName,
+    baseUrl = _ref.baseUrl;
+  var otp = "123456";
+  cy.visit(baseUrl);
+  cy.contains(signUpTexts.tryItFree).click();
+  cy.get(signUpSelectors.signupViaEmailButton).should("contain.text", signUpTexts.email).click();
+  cy.clearAndType(signUpSelectors.emailTextField, email);
+  cy.intercept({
+    url: requestApis.signUp,
+    times: 2
+  }).as("signupRequest");
+  cy.get(signUpSelectors.submitButton).click();
+  cy.wait("@signupRequest");
+  cy.get(signUpSelectors.otpTextBox).type(otp);
+  cy.wait("@signupRequest");
+  cy.clearAndType(signUpSelectors.organizationNameTextField, businessName);
+  cy.intercept({
+    url: requestApis.subdomainAvailablity,
+    times: 1
+  }).as("subdomainRequest");
+  cy.clearAndType(signUpSelectors.subdomainNameTextField, subdomainName);
+  cy.wait("@subdomainRequest");
+  cy.get(signUpSelectors.organizationNameTextField).should("have.value", businessName);
+  cy.get(signUpSelectors.subdomainNameTextField).should("have.value", subdomainName);
+  cy.intercept({
+    url: requestApis.signUp,
+    times: 1
+  }).as("signupRequest");
+  cy.intercept({
+    url: requestApis.countries,
+    times: 1
+  }).as("fetchCountries");
+  cy.get(signUpSelectors.organizationSubmitButton).click();
+  cy.wait("@signupRequest");
+  cy.url({
+    timeout: 15000
+  }).should("include", signUpTexts.profile);
+  cy.wait("@fetchCountries");
+  cy.clearAndType(signUpSelectors.firstNameTextField, firstName);
+  cy.clearAndType(signUpSelectors.lastNameTextField, lastName);
+  cy.intercept({
+    url: requestApis.signUp,
+    times: 1
+  }).as("setupProfile");
+  cy.get(signUpSelectors.profileSubmitButton).click();
+  cy.wait("@setupProfile");
+};
+
+var verifyCrossSiteScript = function verifyCrossSiteScript(inputSelector, submitSelector) {
+  cy.interceptApi("searchRequest");
+  cy.clearAndType(inputSelector, commonTexts.crossSiteScript);
+  submitSelector && cy.get(submitSelector).click();
+  cy.wait("@searchRequest");
+  cy.get(commonSelectors.windowAlert).should("not.exist");
+};
+
+exports.authUtils = authUtils;
+exports.commonSelectors = commonSelectors;
+exports.commonTexts = commonTexts;
+exports.createOrganization = createOrganization;
+exports.dataCy = dataCy;
+exports.dateUtils = dateUtils;
+exports.environment = environment;
+exports.getTestTitle = getTestTitle;
+exports.getUrl = getUrl;
+exports.initializeCredentials = initializeCredentials;
+exports.isStagingEnv = isStagingEnv;
+exports.loginSelectors = loginSelectors;
+exports.memberFormSelectors = memberFormSelectors;
+exports.memberSelectors = memberSelectors;
+exports.memberTableTexts = memberTableTexts;
+exports.memberTexts = memberTexts;
+exports.memberUtils = memberUtils;
+exports.profileSelectors = profileSelectors;
+exports.setListCount = setListCount;
+exports.signUpSelectors = signUpSelectors;
+exports.signUpTexts = signUpTexts;
+exports.tableSelectors = tableSelectors;
+exports.verifyCrossSiteScript = verifyCrossSiteScript;
+exports.verifyListCount = verifyListCount;