@saasquatch/squatch-js 2.6.3-3 → 2.7.0-1

package/dist copy/squatch.js

@@ -0,0 +1,2337 @@
+var debug = require('debug');
+var Cookies = require('js-cookie');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
+var Cookies__default = /*#__PURE__*/_interopDefaultLegacy(Cookies);
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+var DEFAULT_DOMAIN = "https://app.referralsaasquatch.com";
+var DEFAULT_NPM_CDN = "https://fast.ssqt.io/npm";
+var DEFAULT_NAMESPACE = "squatch";
+var IMPACT_NAMESPACE = "impact";
+
+function validateConfig(_raw) {
+  if (typeof _raw !== "object") throw new Error("config must be an object");
+  var tenant = window.squatchTenant;
+  var config = getConfig();
+  var raw = {
+    tenantAlias: (_raw == null ? void 0 : _raw["tenantAlias"]) || tenant,
+    domain: (_raw == null ? void 0 : _raw["domain"]) || (config == null ? void 0 : config.domain),
+    npmCdn: (_raw == null ? void 0 : _raw["npmCdn"]) || (config == null ? void 0 : config.npmCdn),
+    debug: (_raw == null ? void 0 : _raw["debug"]) || (config == null ? void 0 : config.debug)
+  };
+  if (typeof raw.tenantAlias !== "string") throw new Error("tenantAlias not provided");
+  var tenantAlias = raw.tenantAlias;
+  var domain = typeof raw.domain === "string" && raw.domain || DEFAULT_DOMAIN;
+  var debug = typeof raw.debug === "boolean" && raw.debug || false;
+  var npmCdn = typeof raw.npmCdn === "string" && raw.npmCdn || DEFAULT_NPM_CDN;
+  return {
+    tenantAlias,
+    domain,
+    debug,
+    npmCdn
+  };
+}
+function isObject$1(obj) {
+  return typeof obj === "object" && !Array.isArray(obj) && obj !== null;
+}
+function validateLocale(locale) {
+  if (locale && /^[a-z]{2}_(?:[A-Z]{2}|[0-9]{3})$/.test(locale)) {
+    return locale;
+  }
+}
+function validateWidgetConfig(raw) {
+  if (!isObject$1(raw)) throw new Error("Widget properties must be an object");
+  if (!(raw != null && raw["user"])) throw new Error("Required properties missing.");
+  return raw;
+}
+function validatePasswordlessConfig(raw) {
+  if (!isObject$1(raw)) throw new Error("Widget properties must be an object");
+  return raw;
+}
+function getToken() {
+  return window.impactToken || window.squatchToken;
+}
+function getConfig() {
+  return window.impactConfig || window.squatchConfig;
+}
+
+debug.debug("squatch-js:io");
+
+async function doQuery(url, query, variables, jwt) {
+  var token = jwt || getToken();
+
+  var headers = _extends({
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  }, token ? {
+    Authorization: "Bearer " + token
+  } : {}, {
+    "X-SaaSquatch-Referrer": window ? window.location.href : ""
+  });
+
+  try {
+    var res = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify({
+        query,
+        variables
+      }),
+      headers
+    });
+    if (!res.ok) throw new Error(await res.text());
+    return await res.json();
+  } catch (e) {
+    throw e;
+  }
+}
+async function doGet(url, jwt) {
+  if (jwt === void 0) {
+    jwt = "";
+  }
+
+  var headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  var token = jwt || getToken();
+  if (token) headers["X-SaaSquatch-User-Token"] = token;
+
+  try {
+    var res = await fetch(url, {
+      method: "GET",
+      credentials: "include",
+      headers
+    });
+    var reply = await res.text();
+    if (!res.ok) throw new Error(reply);
+    return reply ? JSON.parse(reply) : reply;
+  } catch (e) {
+    throw e;
+  }
+}
+async function doPost(url, data, jwt) {
+  var headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  var token = jwt || getToken();
+  if (token) headers["X-SaaSquatch-User-Token"] = token;
+
+  try {
+    var res = await fetch(url, {
+      method: "POST",
+      body: data,
+      headers
+    });
+    var reply = await res.text();
+    if (!res.ok) throw new Error(reply);
+    return reply ? JSON.parse(reply) : reply;
+  } catch (e) {
+    throw e;
+  }
+}
+async function doPut(url, data, jwt) {
+  var headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "X-SaaSquatch-Referrer": window ? window.location.href : ""
+  };
+  var token = jwt || getToken();
+  if (token) headers["X-SaaSquatch-User-Token"] = token;
+
+  try {
+    var res = await fetch(url, {
+      headers,
+      method: "PUT",
+      credentials: "include",
+      body: data
+    });
+    var reply = await res.text();
+    if (!res.ok) throw new Error(reply);
+    return reply ? JSON.parse(reply) : reply;
+  } catch (e) {
+    throw e;
+  }
+}
+
+var RENDER_WIDGET_QUERY = "\n  query renderWidget ($user: UserIdInput, $engagementMedium: UserEngagementMedium, $widgetType: WidgetType, $locale: RSLocale) {\n    renderWidget(user: $user, engagementMedium: $engagementMedium, widgetType: $widgetType, locale: $locale) {\n      template\n      user {\n        id\n        accountId\n      }\n      jsOptions\n      widgetConfig {\n        values\n      }\n    }\n  }\n";
+
+/**
+ *
+ * The WidgetApi class is a wrapper around the Widget Endpoints of the SaaSquatch REST API.
+ *
+ */
+
+class WidgetApi {
+  /**
+   * Initialize a new {@link WidgetApi} instance.
+   *
+   * @param {ConfigOptions} config Config details
+   *
+   * @example <caption>Browser example</caption>
+   * var squatchApi = new squatch.WidgetApi({tenantAlias:'test_12b5bo1b25125'});
+   *
+   * @example <caption>Browserify/Webpack example</caption>
+   * var WidgetApi = require('@saasquatch/squatch-js').WidgetApi;
+   * var squatchApi = new WidgetApi({tenantAlias:'test_12b5bo1b25125'});
+   *
+   * @example <caption>Babel+Browserify/Webpack example</caption>
+   * import {WidgetApi} from '@saasquatch/squatch-js';
+   * let squatchApi = new WidgetApi({tenantAlias:'test_12b5bo1b25125'});
+   */
+  constructor(config) {
+    this.tenantAlias = void 0;
+    this.domain = void 0;
+    this.npmCdn = void 0;
+    this.referralCookie = this.squatchReferralCookie;
+    var raw = config;
+    var clean = validateConfig(raw);
+    this.tenantAlias = clean.tenantAlias;
+    this.domain = clean.domain;
+    this.npmCdn = clean.npmCdn;
+  }
+  /**
+   * Creates/upserts user, requests widget template.
+   *
+   * @param {Object} params Parameters for request
+   * @param {Object?} params.user The user details
+   * @param {string} params.user.id The user id
+   * @param {string} params.user.accountId The user account id
+   * @param {WidgetType} params.widgetType The content of the widget.
+   * @param {EngagementMedium?} params.engagementMedium How to display the widget.
+   * @param {string?} params.jwt the JSON Web Token (JWT) that is used
+   *                            to validate the data (can be disabled)
+   *
+   * @return {Promise} string if true, with the widget template, jsOptions and user details.
+   */
+
+
+  upsertUser(params) {
+    var raw = params;
+    var clean = validateWidgetConfig(raw);
+    var {
+      widgetType,
+      engagementMedium = "POPUP",
+      jwt,
+      locale,
+      user
+    } = clean;
+    var tenantAlias = encodeURIComponent(this.tenantAlias);
+    var accountId = user.accountId ? encodeURIComponent(user.accountId) : null;
+    var userId = user.id ? encodeURIComponent(user.id) : null;
+
+    var optionalParams = _buildParams({
+      widgetType,
+      engagementMedium,
+      locale
+    });
+
+    var path = "/api/v1/" + tenantAlias + "/widget/account/" + accountId + "/user/" + userId + "/upsert" + optionalParams;
+    var url = this.domain + path;
+    var cookies = (Cookies__default['default'] || window.Cookies).get("_saasquatch");
+    if (cookies) user["cookies"] = cookies;
+    return doPut(url, JSON.stringify(user), jwt);
+  }
+  /**
+   * Requests widget template
+   *
+   * @param {Object} params Parameters for request
+   * @param {Object} params.user The user details
+   * @param {string} params.user.id The user id
+   * @param {string} params.user.accountId The user account id
+   * @param {WidgetType} params.widgetType The content of the widget.
+   * @param {EngagementMedium} params.engagementMedium How to display the widget.
+   * @param {string} params.jwt the JSON Web Token (JWT) that is used
+   *                            to validate the data (can be disabled)
+   * @return {Promise} template html if true.
+   */
+
+
+  render(params) {
+    var _clean$locale;
+
+    var raw = params;
+    var clean = validatePasswordlessConfig(raw);
+    var {
+      widgetType,
+      engagementMedium = "POPUP",
+      jwt,
+      user
+    } = clean;
+    var tenantAlias = encodeURIComponent(this.tenantAlias);
+    var accountId = user != null && user.accountId ? encodeURIComponent(user.accountId) : null;
+    var userId = user != null && user.id ? encodeURIComponent(user.id) : null;
+    var locale = (_clean$locale = clean.locale) != null ? _clean$locale : validateLocale(navigator.language.replace(/\-/g, "_"));
+    var path = "/api/v1/" + tenantAlias + "/graphql";
+    var url = this.domain + path;
+    return new Promise(async (resolve, reject) => {
+      try {
+        var _res$data;
+
+        var res = await doQuery(url, RENDER_WIDGET_QUERY, {
+          user: userId && accountId ? {
+            id: userId,
+            accountId
+          } : null,
+          engagementMedium,
+          widgetType,
+          locale
+        }, jwt);
+        resolve(res == null ? void 0 : (_res$data = res.data) == null ? void 0 : _res$data.renderWidget);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  /**
+   * Looks up the referral code of the current user, if there is any.
+   *
+   * @return {Promise<ReferralCookie>} code referral code if true.
+   */
+
+
+  async squatchReferralCookie() {
+    var tenantAlias = encodeURIComponent(this.tenantAlias);
+
+    var _saasquatch = (Cookies__default['default'] || window.Cookies).get("_saasquatch") || "";
+
+    var cookie = _saasquatch ? "?cookies=" + encodeURIComponent(_saasquatch) : "";
+    var url = this.domain + "/a/" + tenantAlias + "/widgets/squatchcookiejson" + cookie;
+    var response = await doGet(url);
+    return Promise.resolve(_extends({}, response, {
+      encodedCookie: _saasquatch
+    }));
+  }
+
+} // builds a param string for widgets
+
+function _buildParams(_ref) {
+  var {
+    widgetType,
+    engagementMedium,
+    locale
+  } = _ref;
+  var queryParams = new URLSearchParams();
+  queryParams.append("engagementMedium", engagementMedium);
+  if (widgetType) queryParams.append("widgetType", widgetType);
+  if (locale) queryParams.append("locale", locale);
+  return "?" + queryParams.toString();
+}
+
+// @ts-check
+/**
+ *
+ * The AnalyticsApi class is a wrapper around the Analytics Endpoints of
+ * the SaaSquatch REST API. Used to record Widget events.
+ *
+ * @hidden
+ */
+
+class AnalyticsApi {
+  /**
+   * Initialize a new {@link AnalyticsApi} instance.
+   *
+   * @param {Object} config Config details
+   * @param {string} [config.domain='https://app.referralsaasquatch.com'] The server domain.
+   *
+   */
+  constructor(config) {
+    var _getConfig;
+
+    this.domain = void 0;
+    var raw = config;
+
+    var clean = _validateAnalyticsConfig(raw);
+
+    this.domain = (clean == null ? void 0 : clean["domain"]) || ((_getConfig = getConfig()) == null ? void 0 : _getConfig.domain) || DEFAULT_DOMAIN;
+  }
+
+  pushAnalyticsLoadEvent(params) {
+    if (!params.externalUserId || !params.externalAccountId) return;
+    var tenantAlias = encodeURIComponent(params.tenantAlias);
+    var accountId = encodeURIComponent(params.externalAccountId);
+    var userId = encodeURIComponent(params.externalUserId);
+    var engagementMedium = encodeURIComponent(params.engagementMedium);
+    var programId = params.programId ? "&programId=" + encodeURIComponent(params.programId) : "";
+    var path = "/a/" + tenantAlias + "/widgets/analytics/loaded?externalAccountId=" + accountId + "&externalUserId=" + userId + "&engagementMedium=" + engagementMedium + programId;
+    var url = this.domain + path;
+    return doPost(url, JSON.stringify({}));
+  }
+
+  pushAnalyticsShareClickedEvent(params) {
+    var tenantAlias = encodeURIComponent(params.tenantAlias);
+    var accountId = encodeURIComponent(params.externalAccountId);
+    var userId = encodeURIComponent(params.externalUserId);
+    var engagementMedium = encodeURIComponent(params.engagementMedium);
+    var shareMedium = encodeURIComponent(params.shareMedium);
+    var path = "/a/" + tenantAlias + "/widgets/analytics/shared?externalAccountId=" + accountId + "&externalUserId=" + userId + "&engagementMedium=" + engagementMedium + "&shareMedium=" + shareMedium;
+    var url = this.domain + path;
+    return doPost(url, JSON.stringify({}));
+  }
+
+}
+
+function _validateAnalyticsConfig(raw) {
+  if (!isObject$1(raw)) throw new Error("'options' should be an object");
+  return raw;
+}
+
+/** @hidden */
+
+var _log$8 = debug.debug("squatch-js:widget");
+/*
+ * The Widget class is the base class for the different widget types available
+ *
+ * Creates an `iframe` in which the html content of the widget gets embedded.
+ * Uses element-resize-detector (https://github.com/wnr/element-resize-detector)
+ * for listening to the height of the widget content and make the iframe responsive.
+ *
+ */
+
+
+class Widget {
+  constructor(params) {
+    var _params$context;
+
+    this.type = void 0;
+    this.content = void 0;
+    this.analyticsApi = void 0;
+    this.widgetApi = void 0;
+    this.context = void 0;
+    this.npmCdn = void 0;
+    this.container = void 0;
+    this.loadEventListener = null;
+
+    _log$8("widget initializing ...");
+
+    this.content = params.content === "error" ? this._error(params.rsCode) : params.content;
+    this.type = params.type;
+    this.widgetApi = params.api;
+    this.npmCdn = params.npmCdn;
+    this.analyticsApi = new AnalyticsApi({
+      domain: params.domain
+    });
+    this.context = params.context;
+    this.container = ((_params$context = params.context) == null ? void 0 : _params$context.container) || params.container;
+  }
+
+  _findElement() {
+    var element;
+
+    if (typeof this.container === "string") {
+      // selector is a string
+      element = document.querySelector(this.container);
+
+      _log$8("loading widget with selector", element); // selector is an HTML element
+
+    } else if (this.container instanceof HTMLElement) {
+      element = this.container;
+
+      _log$8("loading widget with container", element); // garbage container found
+
+    } else if (this.container) {
+      element = null;
+
+      _log$8("container must be an HTMLElement or string", this.container); // find element on page
+
+    } else {
+      element = document.querySelector("#squatchembed") || document.querySelector(".squatchembed") || document.querySelector("#impactembed") || document.querySelector(".impactembed");
+
+      _log$8("loading widget with default selector", element);
+    }
+
+    if (!(element instanceof HTMLElement)) throw new Error("element with selector '" + (this.container || "#squatchembed, .squatchembed, #impactembed, or .impactembed") + "' not found.'");
+    return element;
+  }
+
+  _createFrame() {
+    var frame = document.createElement("iframe");
+    frame["squatchJsApi"] = this;
+    frame.id = "squatchFrame";
+    frame.width = "100%";
+    frame.src = "about:blank";
+    frame.scrolling = "no";
+    frame.setAttribute("style", "border: 0; background-color: none; width: 1px; min-width: 100%;");
+    return frame;
+  }
+
+  _findFrame() {
+    var element = this.container ? this._findElement() : document.body;
+    var parent = element.shadowRoot || element;
+    return parent.querySelector("iframe#squatchFrame");
+  }
+
+  _detachLoadEventListener(frameDoc) {
+    if (this.loadEventListener) {
+      frameDoc.removeEventListener("sq:user-registration", this.loadEventListener);
+      this.loadEventListener = null;
+    }
+  }
+
+  _attachLoadEventListener(frameDoc, sqh) {
+    if (this.loadEventListener === null) {
+      this.loadEventListener = e => {
+        this._loadEvent(_extends({}, sqh, {
+          userId: e.detail.userId,
+          accountId: e.detail.accountId
+        }));
+      };
+
+      frameDoc.addEventListener("sq:user-registration", this.loadEventListener);
+    }
+  }
+
+  _loadEvent(sqh) {
+    var _this$analyticsApi$pu;
+
+    if (!sqh) return; // No non-truthy value
+
+    if (!isObject$1(sqh)) {
+      throw new Error("Widget Load event identity property is not an object");
+    }
+
+    var params;
+
+    if ("programId" in sqh) {
+      if (!sqh.tenantAlias || !sqh.accountId || !sqh.userId || !sqh.engagementMedium) throw new Error("Widget Load event missing required properties");
+      params = {
+        tenantAlias: sqh.tenantAlias,
+        externalAccountId: sqh.accountId,
+        externalUserId: sqh.userId,
+        engagementMedium: sqh.engagementMedium,
+        programId: sqh.programId
+      };
+    } else {
+      var {
+        analytics,
+        mode
+      } = sqh;
+      params = {
+        tenantAlias: analytics.attributes.tenant,
+        externalAccountId: analytics.attributes.accountId,
+        externalUserId: analytics.attributes.userId,
+        engagementMedium: mode.widgetMode
+      };
+    }
+
+    (_this$analyticsApi$pu = this.analyticsApi.pushAnalyticsLoadEvent(params)) == null ? void 0 : _this$analyticsApi$pu.then(response => {
+      _log$8(params.engagementMedium + " loaded event recorded.");
+    }).catch(ex => {
+      _log$8("ERROR: pushAnalyticsLoadEvent() " + ex);
+    });
+  }
+
+  _shareEvent(sqh, medium) {
+    if (sqh) {
+      this.analyticsApi.pushAnalyticsShareClickedEvent({
+        tenantAlias: sqh.analytics.attributes.tenant,
+        externalAccountId: sqh.analytics.attributes.accountId,
+        externalUserId: sqh.analytics.attributes.userId,
+        engagementMedium: sqh.mode.widgetMode,
+        shareMedium: medium
+      }).then(response => {
+        _log$8(sqh.mode.widgetMode + " share " + medium + " event recorded. " + response);
+      }).catch(ex => {
+        _log$8("ERROR: pushAnalyticsShareClickedEvent() " + ex);
+      });
+    }
+  }
+
+  _error(rs, mode, style) {
+    if (mode === void 0) {
+      mode = "modal";
+    }
+
+    if (style === void 0) {
+      style = "";
+    }
+
+    var errorTemplate = "<!DOCTYPE html>\n    <!--[if IE 7]><html class=\"ie7 oldie\" lang=\"en\"><![endif]-->\n    <!--[if IE 8]><html class=\"ie8 oldie\" lang=\"en\"><![endif]-->\n    <!--[if gt IE 8]><!--><html lang=\"en\"><!--<![endif]-->\n    <head>\n      <link rel=\"stylesheet\" media=\"all\" href=\"https://fast.ssqt.io/assets/css/widget/errorpage.css\">\n      <style>\n        " + style + "\n      </style>\n    </head>\n    <body>\n\n      <div class=\"squatch-container " + mode + "\" style=\"width:100%\">\n        <div class=\"errorheader\">\n          <button type=\"button\" class=\"close\" onclick=\"window.frameElement.squatchJsApi.close();\">&times;</button>\n          <p class=\"errortitle\">Error</p>\n        </div>\n        <div class=\"errorbody\">\n          <div class=\"sadface\"><img src=\"https://fast.ssqt.io/assets/images/face.png\"></div>\n          <h4>Our referral program is temporarily unavailable.</h4><br>\n          <p>Please reload the page or check back later.</p>\n          <p>If the persists please contact our support team.</p>\n          <br>\n          <br>\n          <div class=\"right-align errtxt\">\n            Error Code: " + rs + "\n          </div>\n        </div>\n      </div>\n    </body>\n    </html>";
+    return errorTemplate;
+  }
+
+  async _findInnerContainer(frame) {
+    var {
+      contentWindow
+    } = frame;
+    if (!contentWindow) throw new Error("Squatch.js frame inner frame is empty");
+    var frameDoc = contentWindow.document;
+
+    function search() {
+      var containers = frameDoc.getElementsByTagName("sqh-global-container");
+      var legacyContainers = frameDoc.getElementsByClassName("squatch-container");
+      var fallback = containers.length > 0 ? containers[0] : legacyContainers.length > 0 ? legacyContainers[0] : null;
+      return fallback;
+    }
+
+    var found = null;
+
+    for (var i = 0; i < 5; i++) {
+      found = search();
+      if (found) break;
+      await delay(100);
+    }
+
+    if (!found) {
+      return frameDoc.body;
+    }
+
+    return found;
+  }
+  /**
+   * Reloads the current widget, makes updated request to API and renders result.
+   * Primarily for Classic widgets with registration
+   * @param param0 Form field values
+   * @param jwt JWT for API authentication
+   */
+
+
+  reload(_ref, jwt) {
+    var {
+      email,
+      firstName,
+      lastName
+    } = _ref;
+
+    var frame = this._findFrame();
+
+    if (!frame) throw new Error("Could not find widget iframe");
+    var frameWindow = frame.contentWindow;
+    var engagementMedium = this.context.engagementMedium || "POPUP";
+
+    if (!frameWindow) {
+      throw new Error("Frame needs a content window");
+    }
+
+    var response;
+
+    if (this.context.type === "upsert") {
+      if (!this.context.user) throw new Error("Can't reload without user ids");
+      var userObj = {
+        email: email || null,
+        firstName: firstName || null,
+        lastName: lastName || null,
+        id: this.context.user.id,
+        accountId: this.context.user.accountId
+      };
+      response = this.widgetApi.upsertUser({
+        user: userObj,
+        engagementMedium,
+        widgetType: this.type,
+        jwt
+      });
+    } else if (this.context.type === "passwordless") {
+      response = this.widgetApi.render({
+        user: undefined,
+        engagementMedium,
+        widgetType: this.type,
+        jwt: undefined
+      });
+    } else {
+      throw new Error("can't reload an error widget");
+    }
+
+    response.then(_ref2 => {
+      var {
+        template
+      } = _ref2;
+
+      if (template) {
+        this.content = template; // Support for classic widget registration forms
+
+        this.__deprecated__register(frame, {
+          email,
+          engagementMedium
+        }, () => {
+          this.load(); // @ts-ignore -- open exists in the PopupWidget, so this call will always exist when it's called.
+
+          engagementMedium === "POPUP" && this.open();
+        });
+      }
+    }).catch(_ref3 => {
+      var {
+        message
+      } = _ref3;
+
+      _log$8("" + message);
+    });
+  }
+
+  __deprecated__register(frame, params, onClick) {
+    var frameWindow = frame.contentWindow;
+    var frameDoc = frameWindow.document;
+    var showStatsBtn = frameDoc.createElement("button");
+    var registerForm = frameDoc.getElementsByClassName("squatch-register")[0];
+
+    if (registerForm) {
+      showStatsBtn.className = "btn btn-primary";
+      showStatsBtn.id = "show-stats-btn";
+      showStatsBtn.textContent = this.type === "REFERRER_WIDGET" ? "Show Stats" : "Show Reward";
+      var widgetStyle = params.engagementMedium === "POPUP" ? "margin-top: 10px; max-width: 130px; width: 100%;" : "margin-top: 10px;";
+      showStatsBtn.setAttribute("style", widgetStyle);
+      showStatsBtn.onclick = onClick; // @ts-ignore -- expect register form to be a stylable element
+
+      registerForm.style.paddingTop = "30px";
+      registerForm.innerHTML = "<p><strong>" + params.email + "</strong><br>Has been successfully registered</p>";
+      registerForm.appendChild(showStatsBtn);
+    }
+  }
+
+}
+
+function delay(duration) {
+  return new Promise(resolve => {
+    setTimeout(resolve, duration);
+  });
+}
+
+/*!
+ * domready (c) Dustin Diaz 2014 - License MIT
+ *
+ */
+function domready(targetDoc, fn) {
+  var fns = [];
+  var listener;
+  var doc = targetDoc;
+  var hack = doc.documentElement.doScroll;
+  var domContentLoaded = "DOMContentLoaded";
+  var loaded = (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState);
+  if (!loaded) doc.addEventListener(domContentLoaded, listener = () => {
+    doc.removeEventListener(domContentLoaded, listener);
+    loaded = true;
+
+    while (listener = fns.shift()) {
+      listener();
+    }
+  }); // @ts-ignore
+
+  return loaded ? setTimeout(fn, 0) : fns.push(fn);
+}
+
+// @ts-check
+
+var _log$7 = debug.debug("squatch-js:EMBEDwidget");
+/**
+ * An EmbedWidget is displayed inline in part of your page.
+ *
+ * To create an EmbedWidget use {@link Widgets}
+ *
+ * @example
+ * const widget = new EmbedWidget({ ... })
+ * widget.load() // Loads widget into the DOM
+ * widget.open() // Makes the iframe container visible
+ * widget.close() // Hides the iframe container
+ */
+
+
+class EmbedWidget extends Widget {
+  constructor(params, container) {
+    super(params);
+    this.show = this.open;
+    this.hide = this.close;
+    if (container) this.container = container;
+  }
+
+  async load() {
+    var _this$context;
+
+    var frame = this._createFrame();
+
+    var element = this._findElement();
+
+    if ((_this$context = this.context) != null && _this$context.container) {
+      // Custom container is used
+      element.style.visibility = "hidden";
+      element.style.height = "0";
+      element.style["overflow-y"] = "hidden";
+    }
+
+    if (this.container) {
+      if (element.shadowRoot) {
+        var _element$shadowRoot$l;
+
+        if (((_element$shadowRoot$l = element.shadowRoot.lastChild) == null ? void 0 : _element$shadowRoot$l.nodeName) === "IFRAME") {
+          element.shadowRoot.replaceChild(frame, element.shadowRoot.lastChild);
+        } else {
+          element.shadowRoot.appendChild(frame);
+        }
+      } // Widget reloaded - replace existing element
+      else if (element.firstChild) {
+        element.replaceChild(frame, element.firstChild); // Add iframe for the first time
+      } else {
+        element.appendChild(frame);
+      }
+    } else if (!element.firstChild || element.firstChild.nodeName === "#text") {
+      element.appendChild(frame);
+    }
+
+    var {
+      contentWindow
+    } = frame;
+
+    if (!contentWindow) {
+      throw new Error("Frame needs a content window");
+    }
+
+    var frameDoc = contentWindow.document;
+    frameDoc.open();
+    frameDoc.write(this.content);
+    frameDoc.write("<script src=\"" + this.npmCdn + "/resize-observer-polyfill@1.5.x\"></script>");
+    frameDoc.close();
+    domready(frameDoc, async () => {
+      var _sqh = contentWindow.squatch || contentWindow.widgetIdent; // @ts-ignore -- number will be cast to string by browsers
+
+
+      frame.height = frameDoc.body.scrollHeight; // Adjust frame height when size of body changes
+
+      /* istanbul ignore next: hard to test */
+
+      var ro = new contentWindow["ResizeObserver"](entries => {
+        for (var entry of entries) {
+          var {
+            height
+          } = entry.contentRect; // @ts-ignore -- number will be cast to string by browsers
+
+          frame.height = height;
+        }
+      });
+      var container = await this._findInnerContainer(frame);
+      ro.observe(container);
+
+      if (this._shouldFireLoadEvent()) {
+        this._loadEvent(_sqh);
+
+        _log$7("loaded");
+      } else if (frameDoc) {
+        this._attachLoadEventListener(frameDoc, _sqh);
+      }
+    });
+  }
+  /**
+   * Un-hide if element is available and refresh data
+   */
+
+
+  open() {
+    var frame = this._findFrame();
+
+    if (!frame) return _log$7("no target element to open");
+    if (!frame.contentWindow) return _log$7("Frame needs a content window");
+
+    var element = this._findElement();
+
+    element.style.visibility = "unset";
+    element.style.height = "auto";
+    element.style["overflow-y"] = "auto";
+    frame.contentWindow.document.dispatchEvent(new CustomEvent("sq:refresh"));
+
+    var _sqh = frame.contentWindow.squatch || frame.contentWindow.widgetIdent;
+
+    if (this.context.user) {
+      this._loadEvent(_sqh);
+
+      _log$7("loaded");
+    } else {
+      if (!frame.contentDocument) return;
+
+      this._attachLoadEventListener(frame.contentDocument, _sqh);
+    }
+  }
+
+  close() {
+    var frame = this._findFrame();
+
+    if (!frame) return _log$7("no target element to close");
+    if (frame.contentDocument) this._detachLoadEventListener(frame.contentDocument);
+
+    var element = this._findElement();
+
+    element.style.visibility = "hidden";
+    element.style.height = "0";
+    element.style["overflow-y"] = "hidden";
+
+    _log$7("Embed widget closed");
+  }
+
+  _error(rs, mode, style) {
+    if (mode === void 0) {
+      mode = "embed";
+    }
+
+    if (style === void 0) {
+      style = "";
+    }
+
+    return super._error(rs, mode, style);
+  }
+
+  _shouldFireLoadEvent() {
+    var noContainer = !this.container;
+    var isComponent = this.container instanceof HTMLElement && (this.container.tagName.startsWith("SQUATCH-") || this.container.tagName.startsWith("IMPACT-"));
+    var isVerified = !!this.context.user;
+    return isVerified && (noContainer || isComponent);
+  }
+
+}
+
+// @ts-check
+
+var _log$6 = debug.debug("squatch-js:POPUPwidget");
+
+var popupId = 0;
+/**
+ * The PopupWidget is used to display popups (also known as "Modals").
+ * Popups widgets are rendered on top of other elements in a page.
+ *
+ * To create a PopupWidget use {@link Widgets}
+ *
+ * @example
+ * const widget = new PopupWidget({ ... })
+ * widget.load() // Loads the widget into a dialog element
+ * widget.open() // Opens the dialog element
+ * widget.close() // Hides the dialog element
+ */
+
+class PopupWidget extends Widget {
+  constructor(params, trigger) {
+    if (trigger === void 0) {
+      trigger = ".squatchpop";
+    }
+
+    super(params);
+    this.trigger = void 0;
+    this.id = void 0;
+    this.show = this.open;
+    this.hide = this.close;
+    this.trigger = trigger;
+
+    if (this.container) {
+      this.id = "squatchModal";
+    } else {
+      this.id = popupId === 0 ? "squatchModal" : "squatchModal__" + popupId;
+      popupId = popupId + 1;
+    }
+
+    document.head.insertAdjacentHTML("beforeend", "<style>#" + this.id + "::-webkit-scrollbar { display: none; }</style>");
+  }
+
+  _initialiseCTA() {
+    if (!this.trigger) return;
+    var triggerElement;
+
+    try {
+      triggerElement
+      /* HTMLButton */
+      = document.querySelector(this.trigger) || document.querySelector(".impactpop");
+      if (this.trigger && !triggerElement) _log$6("No element found with trigger selector", this.trigger);
+    } catch (_unused) {
+      _log$6("Not a valid selector", this.trigger);
+    } // Trigger is optional
+
+
+    if (triggerElement) {
+      triggerElement.onclick = () => {
+        this.open();
+      };
+    }
+  }
+
+  _createPopupDialog() {
+    var dialog = document.createElement("dialog");
+    dialog.id = this.id;
+    dialog.setAttribute("style", "width: 100%; max-width: 500px; border: none; padding: 0;");
+
+    var onClick = e => {
+      e.stopPropagation();
+      if (e.target === dialog) dialog.close();
+    };
+
+    dialog.addEventListener("click", onClick);
+    return dialog;
+  }
+
+  async load() {
+    var _dialogParent$lastChi;
+
+    var frame = this._createFrame();
+
+    this._initialiseCTA();
+
+    var element = this.container ? this._findElement() : document.body;
+    var dialogParent = element.shadowRoot || element;
+
+    var dialog = this._createPopupDialog();
+
+    dialog.appendChild(frame);
+
+    if (((_dialogParent$lastChi = dialogParent.lastChild) == null ? void 0 : _dialogParent$lastChi.nodeName) === "DIALOG") {
+      // Was reloaded
+      dialogParent.replaceChild(dialog, dialogParent.lastChild);
+    } else {
+      // First time rendering
+      dialogParent.appendChild(dialog);
+    }
+
+    var {
+      contentWindow
+    } = frame;
+
+    if (!contentWindow) {
+      throw new Error("Frame needs a content window");
+    }
+
+    var frameDoc = contentWindow.document;
+    frameDoc.open();
+    frameDoc.write(this.content);
+    frameDoc.write("<script src=\"" + this.npmCdn + "/resize-observer-polyfill@1.5.x\"></script>");
+    frameDoc.close();
+
+    _log$6("Popup template loaded into iframe");
+
+    await this._setupResizeHandler(frame);
+  }
+
+  async _setupResizeHandler(frame) {
+    var {
+      contentWindow
+    } = frame;
+
+    if (!contentWindow) {
+      throw new Error("Frame needs a content window");
+    }
+
+    var frameDoc = contentWindow.document; // Adjust frame height when size of body changes
+
+    domready(frameDoc, async () => {
+      frameDoc.body.style.overflowY = "hidden";
+      frame.height = frameDoc.body.offsetHeight + "px"; // Adjust frame height when size of body changes
+
+      var ro = new contentWindow["ResizeObserver"](entries => {
+        for (var entry of entries) {
+          var {
+            top,
+            bottom
+          } = entry.contentRect;
+          var computedHeight = bottom + top;
+          frame.height = computedHeight + ""; // Don't let anything else set the height of this element
+
+          entry.target.style = "";
+        }
+      });
+      ro.observe(await this._findInnerContainer(frame));
+    });
+  }
+
+  open() {
+    var element = this.container ? this._findElement() : document.body;
+    var parent = element.shadowRoot || element;
+    var dialog = parent.querySelector("#" + this.id);
+    if (!dialog) throw new Error("Could not determine container div");
+    dialog.showModal();
+
+    var frame = this._findFrame();
+
+    if (!frame) throw new Error("Could not find iframe");
+    var {
+      contentWindow
+    } = frame;
+    if (!contentWindow) throw new Error("Squatch.js has an empty iframe");
+    var frameDoc = contentWindow.document; // Adjust frame height when size of body changes
+
+    domready(frameDoc, () => {
+      var _frame$contentDocumen;
+
+      var _sqh = contentWindow.squatch || contentWindow.widgetIdent;
+
+      (_frame$contentDocumen = frame.contentDocument) == null ? void 0 : _frame$contentDocumen.dispatchEvent(new CustomEvent("sq:refresh"));
+
+      if (this.context.user) {
+        this._loadEvent(_sqh);
+
+        _log$6("Popup opened");
+      } else {
+        this._attachLoadEventListener(frameDoc, _sqh);
+      }
+    });
+  }
+
+  close() {
+    var frame = this._findFrame();
+
+    if (frame != null && frame.contentDocument) this._detachLoadEventListener(frame.contentDocument);
+    var element = this.container ? this._findElement() : document.body;
+    var parent = element.shadowRoot || element;
+    var dialog = parent.querySelector("#" + this.id);
+    if (!dialog) throw new Error("Could not determine container div");
+    dialog.close();
+
+    _log$6("Popup closed");
+  }
+
+  _clickedOutside(_ref) {
+  }
+
+  _error(rs, mode, style) {
+    if (mode === void 0) {
+      mode = "modal";
+    }
+
+    if (style === void 0) {
+      style = "";
+    }
+
+    var _style = "body { margin: 0; } .modal { box-shadow: none; border: 0; }";
+    return super._error(rs, mode, style || _style);
+  }
+
+}
+
+var _log$5 = debug.debug("squatch-js:widgets");
+/**
+ * `Widgets` is a factory for creating widgets. It's possible to build your own widgets using the
+ * {@link WidgetApi} but most people will prefer to use these easy methods.
+ * @class
+ */
+
+
+class Widgets {
+  /**
+   * Instance of {@link WidgetApi}
+   */
+
+  /**
+   * Tenant alias of SaaSquatch tenant
+   */
+
+  /**
+   * SaaSquatch domain for API requests
+   * @default "https://app.referralsaasquatch.com"
+   */
+
+  /**
+   * Hosted CDN for npm packages
+   * @default "https://fast.ssqt.io/npm"
+   */
+
+  /**
+   * Initialize a new {@link Widgets} instance.
+   *
+   * @param {ConfigOptions} config Config details
+   *
+   * @example <caption>Browser example</caption>
+   * var widgets = new squatch.Widgets({tenantAlias:'test_12b5bo1b25125'});
+   *
+   * @example <caption>Browserify/Webpack example</caption>
+   * var Widgets = require('@saasquatch/squatch-js').Widgets;
+   * var widgets = new Widgets({tenantAlias:'test_12b5bo1b25125'});
+   *
+   * @example <caption>Babel+Browserify/Webpack example</caption>
+   * import {Widgets} from '@saasquatch/squatch-js';
+   * let widgets = new Widgets({tenantAlias:'test_12b5bo1b25125'});
+   */
+  constructor(configin) {
+    this.api = void 0;
+    this.tenantAlias = void 0;
+    this.domain = void 0;
+    this.npmCdn = void 0;
+    var config = validateConfig(configin);
+    this.tenantAlias = config.tenantAlias;
+    this.domain = config.domain;
+    this.npmCdn = config.npmCdn;
+    this.api = new WidgetApi(config);
+  }
+  /**
+   * This function calls the {@link WidgetApi.upsertUser} method, and it renders
+   * the widget if it is successful. Otherwise it shows the "error" widget.
+   *
+   * @param {Object} config Config details
+   * @param {Object} config.user The user details
+   * @param {string} config.user.id The user id
+   * @param {string} config.user.accountId The user account id
+   * @param {WidgetType} config.widgetType The content of the widget
+   * @param {EngagementMedium} config.engagementMedium How to display the widget
+   * @param {string} config.jwt the JSON Web Token (JWT) that is used to validate the data (can be disabled)
+   * @param {HTMLElement | string | undefined} config.container Element to load the widget into
+   * @param {string | undefined} config.trigger Trigger element for opening the popup widget
+   *
+   * @return {Promise<WidgetResult>} json object if true, with a Widget and user details
+   */
+
+
+  async upsertUser(config) {
+    var raw = config;
+    var clean = validateWidgetConfig(raw);
+
+    try {
+      var response = await this.api.upsertUser(clean);
+      return {
+        widget: this._renderWidget(response, clean, {
+          type: "upsert",
+          user: clean.user,
+          engagementMedium: config.engagementMedium,
+          container: config.container,
+          trigger: config.trigger
+        }),
+        user: response.user
+      };
+    } catch (err) {
+      _log$5(err);
+
+      if (err.apiErrorCode) {
+        this._renderErrorWidget(err, config.engagementMedium);
+      }
+
+      throw new Error(err);
+    }
+  }
+  /**
+   * This function calls the {@link WidgetApi.render} method, and it renders
+   * the widget if it is successful. Otherwise it shows the "error" widget.
+   *
+   * @param {Object} config Config details
+   * @param {Object} config.user The user details
+   * @param {string} config.user.id The user id
+   * @param {string} config.user.accountId The user account id
+   * @param {WidgetType} config.widgetType The content of the widget
+   * @param {EngagementMedium} config.engagementMedium How to display the widget
+   * @param {string} config.jwt the JSON Web Token (JWT) that is used
+   *                            to validate the data (can be disabled)
+   *
+   * @return {Promise<WidgetResult>} json object if true, with a Widget and user details
+   */
+
+
+  async render(config) {
+    var raw = config;
+    var clean = validatePasswordlessConfig(raw);
+
+    try {
+      var response = await this.api.render(clean);
+      return {
+        widget: this._renderWidget(response, clean, {
+          type: "passwordless",
+          engagementMedium: clean.engagementMedium,
+          container: clean.container,
+          trigger: clean.trigger
+        }),
+        user: response.user
+      };
+    } catch (err) {
+      if (err.apiErrorCode) {
+        this._renderErrorWidget(err, clean.engagementMedium);
+      }
+
+      throw new Error(err);
+    }
+  }
+  /**
+   * Autofills a referral code into an element when someone has been referred.
+   * Uses {@link WidgetApi.squatchReferralCookie} behind the scenes.
+   *
+   * @param selector Element class/id selector, or a callback function
+   * @returns
+   */
+
+
+  async autofill(selector) {
+    var input = selector;
+
+    if (typeof input === "function") {
+      try {
+        var response = await this.api.squatchReferralCookie();
+        input(response);
+      } catch (e) {
+        _log$5("Autofill error", e);
+
+        throw new Error(e);
+      }
+
+      return;
+    }
+
+    if (typeof input !== "string") throw new Error("Autofill accepts a string or function");
+    var elems = document.querySelectorAll(input);
+    var elem;
+
+    if (elems.length > 0) {
+      // Only use the first element found
+      elem = elems[0];
+    } else {
+      _log$5("Element id/class or function missing");
+
+      throw new Error("Element id/class or function missing");
+    }
+
+    try {
+      var _response = await this.api.squatchReferralCookie();
+
+      elem.value = _response.codes[0];
+    } catch (e) {
+      throw new Error(e);
+    }
+  }
+  /**
+   * @hidden
+   * @param {Object} response The json object return from the WidgetApi
+   * @param {Object} config Config details
+   * @param {string} config.widgetType The widget type (REFERRER_WIDGET, CONVERSION_WIDGET)
+   * @param {string} config.engagementMedium (POPUP, EMBED)
+   * @returns {Widget} widget (PopupWidget or EmbedWidget)
+   */
+
+
+  _renderWidget(response, config, context) {
+    var _opts$widget;
+
+    _log$5("Rendering Widget...");
+
+    if (!response) throw new Error("Unable to get a response");
+    var widget;
+    var displayOnLoad = !!config.displayOnLoad;
+    var opts = response.jsOptions || {};
+    var params = {
+      content: response.template,
+      type: config.widgetType || ((_opts$widget = opts.widget) == null ? void 0 : _opts$widget.defaultWidgetType),
+      api: this.api,
+      domain: this.domain,
+      npmCdn: this.npmCdn,
+      context: context
+    };
+
+    if (opts.widgetUrlMappings) {
+      opts.widgetUrlMappings.forEach(rule => {
+        if (Widgets._matchesUrl(rule.url)) {
+          var _response$user, _response$user$referr;
+
+          if (rule.widgetType !== "CONVERSION_WIDGET" || (_response$user = response.user) != null && (_response$user$referr = _response$user.referredBy) != null && _response$user$referr.code) {
+            displayOnLoad = rule.displayOnLoad;
+
+            _log$5("Display " + rule.widgetType + " on " + rule.url);
+          } else {
+            _log$5("Don't display " + rule.widgetType + " when no referral on widget rule match " + rule.url);
+          }
+        }
+      });
+    }
+
+    if (opts.fuelTankAutofillUrls) {
+      _log$5("We found a fuel tank autofill!");
+
+      opts.fuelTankAutofillUrls.forEach(_ref => {
+        var {
+          url,
+          formSelector
+        } = _ref;
+
+        if (Widgets._matchesUrl(url)) {
+          var _response$user2, _response$user2$refer;
+
+          _log$5("Fuel Tank URL matches");
+
+          if ((_response$user2 = response.user) != null && (_response$user2$refer = _response$user2.referredBy) != null && _response$user2$refer.code) {
+            var formAutofill = document.querySelector(formSelector);
+
+            if (formAutofill) {
+              var _response$user$referr2;
+
+              formAutofill.value = ((_response$user$referr2 = response.user.referredBy.referredReward) == null ? void 0 : _response$user$referr2.fuelTankCode) || "";
+            } else {
+              _log$5(new Error("Element with id/class " + formSelector + " was not found."));
+            }
+          }
+        }
+      });
+    }
+
+    if (config.engagementMedium === "EMBED") {
+      widget = this._renderEmbedWidget(params);
+    } else {
+      widget = this._renderPopupWidget(params);
+      if (displayOnLoad) widget.open();
+    }
+
+    return widget;
+  }
+
+  _renderPopupWidget(params) {
+    var widget = new PopupWidget(params, params.context.trigger);
+    widget.load();
+    return widget;
+  }
+
+  _renderEmbedWidget(params) {
+    var widget = new EmbedWidget(params, params.context.container);
+    widget.load();
+    return widget;
+  }
+  /**
+   * @hidden
+   * @param {Object} error The json object containing the error details
+   * @param {string} em The engagementMedium
+   * @returns {void}
+   */
+
+
+  _renderErrorWidget(props, em) {
+    if (em === void 0) {
+      em = "POPUP";
+    }
+
+    var {
+      apiErrorCode,
+      rsCode,
+      message
+    } = props;
+
+    _log$5(new Error(apiErrorCode + " (" + rsCode + ") " + message));
+
+    var params = {
+      content: "error",
+      rsCode,
+      api: this.api,
+      domain: this.domain,
+      npmCdn: this.npmCdn,
+      type: "ERROR_WIDGET",
+      context: {
+        type: "error"
+      }
+    };
+    var widget;
+
+    if (em === "EMBED") {
+      widget = new EmbedWidget(params);
+      widget.load();
+    } else if (em === "POPUP") {
+      widget = new PopupWidget(params);
+      widget.load();
+    }
+  }
+  /**
+   * @hidden
+   * @param {string} rule A regular expression
+   * @returns {boolean} true if rule matches Url, false otherwise
+   */
+
+
+  static _matchesUrl(rule) {
+    // If there were no matches, null is returned.
+    return window.location.href.match(new RegExp(rule)) ? true : false;
+  }
+
+}
+
+/**
+ *
+ * The EventsApi class is a wrapper around the open endpoints of the SaaSquatch REST API.
+ *
+ */
+
+class EventsApi {
+  /**
+   * Initialize a new {@link EventsApi} instance.
+   *
+   * @param {ConfigOptions} config Config details
+   *
+   * @example <caption>Browser example</caption>
+   * var squatchApi = new squatch.EventsApi({tenantAlias:'test_12b5bo1b25125'});
+   *
+   * @example <caption>Browserify/Webpack example</caption>
+   * var EventsApi = require('@saasquatch/squatch-js').EventsApi;
+   * var squatchApi = new EventsApi({tenantAlias:'test_12b5bo1b25125'});
+   *
+   * @example <caption>Babel+Browserify/Webpack example</caption>
+   * import {EventsApi} from '@saasquatch/squatch-js';
+   * let squatchApi = new EventsApi({tenantAlias:'test_12b5bo1b25125'});
+   */
+  constructor(config) {
+    this.tenantAlias = void 0;
+    this.domain = void 0;
+    var raw = config; // Flags that we need to validate anything we use from this type
+
+    var clean = validateConfig(raw);
+    this.tenantAlias = clean.tenantAlias;
+    this.domain = clean.domain;
+  }
+  /**
+   * Track an event for a user
+   *
+   * @param params Parameters for request
+   * @param options.jwt the JSON Web Token (JWT) that is used to authenticate the user
+   *
+   * @return An ID to confirm the event has been accepted for asynchronous processing
+   */
+
+
+  track(params, options) {
+    var raw = params;
+    var rawOpts = options;
+
+    var body = _validateEvent(raw);
+
+    var {
+      jwt
+    } = _validateTrackOptions(rawOpts);
+
+    var ta = encodeURIComponent(this.tenantAlias);
+    var userId = encodeURIComponent(body.userId);
+    var accountId = encodeURIComponent(body.accountId);
+    var path = "/api/v1/" + ta + "/open/account/" + accountId + "/user/" + userId + "/events";
+    var url = this.domain + path;
+    return doPost(url, JSON.stringify(body), jwt);
+  }
+
+}
+
+function _validateEvent(raw) {
+  if (!isObject$1(raw)) throw new Error("tracking parameter must be an object");
+  if (!(raw != null && raw["accountId"])) throw new Error("accountId field is required");
+  if (!(raw != null && raw["events"])) throw new Error("events field is required");
+  if (!(raw != null && raw["userId"])) throw new Error("userId field is required");
+  var clean = raw;
+  if (!Array.isArray(clean.events)) throw new Error("'events' should be an array");
+  return clean;
+}
+
+function _validateTrackOptions(raw) {
+  if (!isObject$1(raw)) throw new Error("'options' should be an object");
+  return raw;
+}
+
+/** @hidden */
+
+function asyncLoad() {
+  var _window;
+
+  var namespace = window[IMPACT_NAMESPACE] ? IMPACT_NAMESPACE : DEFAULT_NAMESPACE;
+  var cached = ((_window = window["_" + namespace]) == null ? void 0 : _window.ready) || [];
+  var declarativeCache = window.impactOnReady || window.squatchOnReady;
+  var readyFns = [...cached, declarativeCache].filter(a => !!a); // Run all of this in a setTimeout because we need to wait for the squatch module to finish loading
+
+  setTimeout(() => {
+    // Exit early if module wasn't loaded onto window
+    if (!window[DEFAULT_NAMESPACE]) return; // Set window.impact as an alias for window.squatch.
+
+    window[IMPACT_NAMESPACE] = window[DEFAULT_NAMESPACE]; // Run all the ready functions in a set timeout to they happen after namespace aliasing.
+
+    readyFns.forEach(cb => cb()); // Perform auto popup
+
+    window[DEFAULT_NAMESPACE]._auto(); // @ts-ignore -- intentionally deletes `_squatch` to cleanup initialization
+
+
+    window["_" + namespace] = undefined;
+    delete window["_" + namespace];
+  }, 0);
+}
+
+/** @hidden */
+
+var _log$4 = debug.debug("squatch-js");
+
+var isObject = item => typeof item === "object" && !Array.isArray(item);
+
+var deepMerge = (target, source) => {
+  var isDeep = prop => isObject(source[prop]) && target.hasOwnProperty(prop) && isObject(target[prop]);
+
+  var replaced = Object.getOwnPropertyNames(source).map(prop => ({
+    [prop]: isDeep(prop) ? deepMerge(target[prop], source[prop]) : source[prop]
+  })).reduce((a, b) => _extends({}, a, b), {});
+  return _extends({}, target, replaced);
+}; // inspired by https://github.com/panva/jose/blob/3c4ad55c92bcd9cbc0512438819717d185c41fb2/src/util/decode_jwt.ts#L22
+
+
+function b64decode(input) {
+  var binary = atob(input.replace(/_/g, "/").replace(/-/g, "+"));
+  var bytes = new Uint8Array(binary.length);
+
+  for (var i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+
+  return new TextDecoder("utf8").decode(bytes);
+} // Suggestion from https://developer.mozilla.org/en-US/docs/Glossary/Base64#the_unicode_problem
+
+function b64encode(input) {
+  var encodedInput = new TextEncoder().encode(input);
+  var binary = Array.from(encodedInput, byte => String.fromCodePoint(byte)).join("");
+  return btoa(binary).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+} // https://stackoverflow.com/a/11319865
+
+function getTopDomain() {
+  var i,
+      h,
+      weird_cookie = "weird_get_top_level_domain=cookie",
+      hostname = document.location.hostname.split(".");
+
+  for (i = hostname.length - 1; i >= 0; i--) {
+    h = hostname.slice(i).join(".");
+    document.cookie = weird_cookie + ";domain=." + h + ";";
+
+    if (document.cookie.indexOf(weird_cookie) > -1) {
+      // We were able to store a cookie! This must be it
+      document.cookie = weird_cookie.split("=")[0] + "=;domain=." + h + ";expires=Thu, 01 Jan 1970 00:00:01 GMT;";
+      return h;
+    }
+  }
+}
+
+function _pushCookie() {
+  var queryString = window.location.search;
+  var urlParams = new URLSearchParams(queryString);
+  var refParam = urlParams.get("_saasquatch") || ""; // do nothing if no params
+
+  if (refParam) {
+    var paramsJSON = "",
+        existingCookie = "",
+        reEncodedCookie = "";
+
+    try {
+      paramsJSON = JSON.parse(b64decode(refParam));
+    } catch (error) {
+      _log$4("Unable to decode params", error); // don't merge invalid params
+
+
+      return;
+    }
+
+    try {
+      existingCookie = JSON.parse(b64decode(Cookies__default['default'].get("_saasquatch")));
+
+      _log$4("existing cookie", existingCookie);
+    } catch (error) {
+      _log$4("Unable to retrieve cookie", error);
+    } // don't merge if there's no existing object
+
+
+    try {
+      var domain = getTopDomain();
+
+      _log$4("domain retrieved:", domain);
+
+      if (existingCookie) {
+        var newCookie = deepMerge(existingCookie, paramsJSON);
+        reEncodedCookie = b64encode(JSON.stringify(newCookie));
+
+        _log$4("cookie to store:", newCookie);
+      } else {
+        reEncodedCookie = b64encode(JSON.stringify(paramsJSON));
+
+        _log$4("cookie to store:", paramsJSON);
+      }
+
+      Cookies__default['default'].set("_saasquatch", reEncodedCookie, {
+        expires: 365,
+        secure: false,
+        sameSite: "Lax",
+        domain,
+        path: "/"
+      });
+    } catch (error) {
+      _log$4("Unable to set cookie", error);
+    }
+  }
+}
+
+/** @hidden */
+
+var _log$3 = debug.debug("squatch-js");
+
+function _getAutoConfig(configIn) {
+  var queryString = window.location.search;
+  var urlParams = new URLSearchParams(queryString);
+  var refParam = urlParams.get("_saasquatchExtra") || "";
+
+  if (!refParam) {
+    _log$3("No _saasquatchExtra param");
+
+    return;
+  }
+
+  var raw;
+
+  try {
+    raw = JSON.parse(b64decode(refParam));
+  } catch (e) {
+    _log$3("Unable to decode _saasquatchExtra config");
+
+    return;
+  }
+
+  var {
+    domain,
+    tenantAlias,
+    widgetConfig
+  } = convertExtraToConfig(raw);
+
+  if (!domain || !tenantAlias || !widgetConfig) {
+    _log$3("_saasquatchExtra did not have an expected structure");
+
+    return undefined;
+  }
+
+  var {
+    autoPopupWidgetType
+  } = widgetConfig,
+      rest = _objectWithoutPropertiesLoose(widgetConfig, ["autoPopupWidgetType"]);
+
+  return {
+    widgetConfig: _extends({
+      widgetType: autoPopupWidgetType,
+      displayOnLoad: true
+    }, rest),
+    squatchConfig: _extends({}, configIn ? {
+      configIn
+    } : {}, {
+      domain,
+      tenantAlias
+    })
+  };
+}
+/**
+ * Deconstructs _saasquatchExtra into domain, tenantAlias, and widgetConfig
+ * @param obj {Record<string, any>} Expected to be of the form `{ [appDomain]: { [tenantAlias]: { autoPopupWidgetType: [widgetType], [rest]?: ... } } }`
+ */
+
+function convertExtraToConfig(obj) {
+  var _obj$_domain;
+
+  var _domain = Object.keys(obj || {})[0];
+  var tenantAlias = Object.keys((obj == null ? void 0 : obj[_domain]) || {})[0];
+  var widgetConfig = obj == null ? void 0 : (_obj$_domain = obj[_domain]) == null ? void 0 : _obj$_domain[tenantAlias]; // domain in _saasquatchExtra doesn't contain "https://"
+
+  var domain = _domain ? "https://" + _domain : undefined;
+  return {
+    domain,
+    tenantAlias,
+    widgetConfig
+  };
+}
+
+var _log$2 = debug.debug("squatch-js:decodeUserJwt");
+
+function decodeUserJwt(tokenStr) {
+  try {
+    var _JSON$parse;
+
+    var base64Url = tokenStr.split(".")[1];
+    if (base64Url === undefined) return null;
+    var jsonStr = b64decode(base64Url);
+    return (_JSON$parse = JSON.parse(jsonStr)) == null ? void 0 : _JSON$parse.user;
+  } catch (e) {
+    _log$2(e);
+
+    return null;
+  }
+}
+
+var _log$1 = debug__default['default']("squatch-js:DeclarativeWidget");
+/**
+ * Abstract class for building web-components that render SaaSquatch widgets to the DOM
+ * @abstract
+ * @example
+ * class TestWidgetElement extends DeclarativeWidget {}
+ * const testWidget = new TestWidgetElement()
+ * testWidget.widgetType = 'w/widget-type'
+ * testWidget.type = 'EMBED'
+ * testWidget.renderWidget()
+ */
+
+
+class DeclarativeWidget extends HTMLElement {
+  /**
+   * Configuration overrides
+   * @default window.squatchConfig
+   */
+
+  /**
+   * Signed JWT containing user information
+   * @default window.squatchToken
+   */
+
+  /**
+   * Tenant alias of SaaSquatch tenant
+   * @default window.squatchTenant
+   */
+
+  /**
+   * widgetType of widget to load
+   */
+
+  /**
+   * Locale to render the widget in
+   */
+
+  /**
+   * Instance of {@link WidgetApi}
+   */
+
+  /**
+   * Instance of {@link AnalyticsApi}
+   */
+
+  /**
+   * Instance of {@link EmbedWidget} or {@link PopupWidget}
+   */
+
+  /**
+   * Determines whether to render the widget as an embedding widget or popup widget
+   */
+
+  /**
+   * Container element to contain the widget iframe
+   * @default this
+   */
+
+  /**
+   * Flag for if the component has been loaded or not
+   * @hidden
+   */
+  constructor() {
+    super();
+    this.config = void 0;
+    this.token = void 0;
+    this.tenant = void 0;
+    this.widgetType = void 0;
+    this.locale = void 0;
+    this.widgetApi = void 0;
+    this.analyticsApi = void 0;
+    this.widgetInstance = void 0;
+    this.type = void 0;
+    this.container = void 0;
+    this.element = void 0;
+    this.loaded = void 0;
+
+    this._setWidget = (template, config) => {
+      var _this$config;
+
+      var params = {
+        api: this.widgetApi,
+        content: template,
+        context: {
+          type: config.type,
+          user: config.user,
+          container: this.container || undefined,
+          engagementMedium: this.type
+        },
+        type: this.widgetType,
+        domain: ((_this$config = this.config) == null ? void 0 : _this$config.domain) || DEFAULT_DOMAIN,
+        npmCdn: DEFAULT_NPM_CDN,
+        container: this
+      };
+
+      if (this.type === "EMBED") {
+        return new EmbedWidget(params);
+      } else {
+        var useFirstChildTrigger = this.firstChild ? null : undefined;
+        return new PopupWidget(params, useFirstChildTrigger);
+      }
+    };
+
+    this.setErrorWidget = e => {
+      var _this$config2;
+
+      var params = {
+        api: this.widgetApi,
+        content: "error",
+        context: {
+          type: "error",
+          container: this.container || undefined
+        },
+        type: "ERROR_WIDGET",
+        domain: ((_this$config2 = this.config) == null ? void 0 : _this$config2.domain) || DEFAULT_DOMAIN,
+        npmCdn: DEFAULT_NPM_CDN,
+        container: this
+      };
+
+      if (this.type === "EMBED") {
+        return new EmbedWidget(params);
+      } else {
+        var useFirstChildTrigger = this.firstChild ? null : undefined;
+        return new PopupWidget(params, useFirstChildTrigger);
+      }
+    };
+
+    this.reload = this.renderWidget;
+    this.show = this.open;
+    this.hide = this.close;
+    this.attachShadow({
+      mode: "open"
+    }).innerHTML = "<style>:host { display: block; }</style><slot></slot>";
+    this.config = getConfig();
+    this.token = getToken();
+    this.tenant = window.squatchTenant;
+    this.container = this;
+  }
+
+  _setupApis(config) {
+    var _this$config3, _this$config4;
+
+    if (!this.tenant) throw new Error("tenantAlias not provided");
+    this.widgetApi = new WidgetApi({
+      tenantAlias: (config == null ? void 0 : config.tenantAlias) || this.tenant,
+      domain: (config == null ? void 0 : config.domain) || ((_this$config3 = this.config) == null ? void 0 : _this$config3.domain) || DEFAULT_DOMAIN
+    });
+    this.analyticsApi = new AnalyticsApi({
+      domain: (config == null ? void 0 : config.domain) || ((_this$config4 = this.config) == null ? void 0 : _this$config4.domain) || DEFAULT_DOMAIN
+    });
+  }
+
+  async renderPasswordlessVariant() {
+    this._setupApis();
+
+    _log$1("Rendering as an Instant Access widget");
+
+    return await this.widgetApi.render({
+      engagementMedium: this.type,
+      widgetType: this.widgetType,
+      locale: this.locale
+    }).then(res => this._setWidget(res.template, {
+      type: "passwordless"
+    })).catch(this.setErrorWidget);
+  }
+
+  async renderUserUpsertVariant() {
+    this._setupApis();
+
+    var userObj = decodeUserJwt(this.token);
+
+    if (!userObj) {
+      return this.setErrorWidget(Error("No user object in token."));
+    }
+
+    _log$1("Rendering as a Verified widget");
+
+    var widgetInstance = await this.widgetApi.upsertUser({
+      user: userObj,
+      locale: this.locale,
+      engagementMedium: this.type,
+      widgetType: this.widgetType,
+      jwt: this.token
+    }).then(res => this._setWidget(res.template, {
+      type: "upsert",
+      user: userObj
+    })).catch(this.setErrorWidget);
+    return widgetInstance;
+  }
+
+  /**
+   * Fetches widget content from SaaSquatch and builds a Widget instance to support rendering the widget in the DOM
+   * @returns Instance of either {@link EmbedWidget} or {@link PopupWidget} depending on `this.type`
+   * @throws Throws an Error if `widgetType` is undefined
+   */
+  async getWidgetInstance() {
+    var widgetInstance;
+    this.widgetType = this.getAttribute("widget") || undefined;
+    this.locale = this.getAttribute("locale") || this.locale;
+    if (!this.widgetType) throw new Error("No widget has been specified");
+
+    if (!this.token) {
+      widgetInstance = await this.renderPasswordlessVariant();
+    } else {
+      widgetInstance = await this.renderUserUpsertVariant();
+    }
+
+    this.widgetInstance = widgetInstance;
+    if (this.widgetInstance) this.dispatchEvent(new CustomEvent("sq:widget-loaded"));
+    return widgetInstance;
+  }
+  /**
+   * Calls {@link getWidgetInstance} to build the Widget instance and loads the widget iframe into the DOM
+   */
+
+
+  async renderWidget() {
+    await this.getWidgetInstance();
+    await this.widgetInstance.load();
+  }
+  /**
+   * Builds a Widget instance for the default error widget
+   * @returns Instance of either {@link EmbedWidget} or {@link PopupWidget} depending on `this.type`
+   */
+
+
+  /**
+   * Calls `open` method of `widgetInstance`
+   * @throws Throws an Error if called before the widget has loaded
+   */
+  open() {
+    if (!this.widgetInstance) throw new Error("Widget has not loaded yet");
+    this.widgetInstance.open();
+  }
+  /**
+   * Calls `close` method of `widgetInstance`
+   * @throws Throws an Error if called before the widget has loaded
+   */
+
+
+  close() {
+    if (!this.widgetInstance) throw new Error("Widget has not loaded yet");
+    this.widgetInstance.close();
+  }
+
+}
+
+/**
+ * Base class for `squatch-embed` web-component
+ * @extends {DeclarativeWidget}
+ * @class
+ * @example
+ * window.createCustomElement('squatch-embed', DeclarativeEmbedWidget)
+ * const widget = document.querySelector('squatch-embed') as DeclarativeEmbedWidget
+ * widget.open()
+ * widget.close()
+ * widget.reload()
+ */
+
+class DeclarativeEmbedWidget extends DeclarativeWidget {
+  constructor() {
+    super();
+    /**
+     * @static
+     */
+
+    this.type = "EMBED";
+    this.loaded = false;
+  }
+
+  static get observedAttributes() {
+    return ["widget", "locale"];
+  }
+
+  attributeChangedCallback(attr, oldVal, newVal) {
+    if (oldVal === newVal || !this.loaded) return; // nothing to do
+
+    switch (attr) {
+      case "locale":
+      case "widget":
+        this.connectedCallback();
+        break;
+    }
+  }
+
+  async connectedCallback() {
+    var _ref, _this$shadowRoot;
+
+    this.loaded = true;
+    this.container = this.getAttribute("container");
+    await this.renderWidget();
+    var slot = (_ref = this.shadowRoot && Array.from(this.shadowRoot.children)) == null ? void 0 : _ref.find(c => c.tagName === "SLOT");
+    if (slot) (_this$shadowRoot = this.shadowRoot) == null ? void 0 : _this$shadowRoot.removeChild(slot);
+    if (this.getAttribute("open") !== null) this.open();
+  }
+
+}
+/**
+ * Base class for `squatch-popup` web-component
+ * @extends {DeclarativeWidget}
+ * @class
+ * @example
+ * window.createCustomElement('squatch-popup', DeclarativePopupWidget)
+ * const widget = document.querySelector('squatch-popup') as DeclarativePopupWidget
+ * widget.open()
+ * widget.close()
+ * widget.reload()
+ */
+
+class DeclarativePopupWidget extends DeclarativeWidget {
+  constructor() {
+    super();
+    /**
+     * @static
+     */
+
+    this.type = "POPUP";
+    this.loaded = false;
+    this.addEventListener("click", e => {
+      e.stopPropagation();
+      this.open();
+    });
+  }
+
+  static get observedAttributes() {
+    return ["widget", "locale"];
+  }
+
+  attributeChangedCallback(attr, oldVal, newVal) {
+    if (oldVal === newVal || !this.loaded) return; // nothing to do
+
+    switch (attr) {
+      case "locale":
+      case "widget":
+        this.connectedCallback();
+        break;
+    }
+  }
+
+  async connectedCallback() {
+    this.loaded = true;
+    this.container = this.getAttribute("container");
+    await this.renderWidget();
+    if (this.getAttribute("open") !== null) this.open();
+  }
+
+}
+
+class SquatchEmbed extends DeclarativeEmbedWidget {}
+
+class SquatchPopup extends DeclarativePopupWidget {}
+
+class ImpactEmbed extends DeclarativeEmbedWidget {}
+
+class ImpactPopup extends DeclarativePopupWidget {}
+
+if (!window.customElements.get("squatch-embed")) window.customElements.define("squatch-embed", SquatchEmbed);
+if (!window.customElements.get("impact-embed")) window.customElements.define("impact-embed", ImpactEmbed);
+if (!window.customElements.get("squatch-popup")) window.customElements.define("squatch-popup", SquatchPopup);
+if (!window.customElements.get("impact-popup")) window.customElements.define("impact-popup", ImpactPopup);
+
+// @ts-check
+function help() {
+  console.log("Having trouble using Squatch.js? Go to https://docs.referralsaasquatch.com/developer/ for tutorials, references and error codes.");
+}
+
+var _window$squatch;
+// debug.disable("squatch-js*");
+
+/** @hidden */
+
+var _log = debug.debug("squatch-js");
+/** @hidden */
+
+var _api = null;
+/** @hidden */
+
+var _widgets = null;
+/** @hidden */
+
+var _events = null;
+/**
+ * A static instance of the {@link WidgetApi} created when you call {@link #init init}.
+ *
+ * Read the {@link WidgetApi} docs.
+ *
+ * @returns WidgetApi static instance
+ * @example
+ * squatch.api().render({ ... })
+ * squatch.api().upsertUser({ ... })
+ * squatch.api().squatchReferralCookie()
+ */
+
+function api() {
+  if (!_api) init({});
+  return _api;
+}
+/**
+ * A static instance of the {@link Widgets} created when you call {@link #init init}.
+ *
+ * Read the {@link Widgets} docs.
+ *
+ * @returns static instance
+ * @example
+ * squatch.widgets().render({ widgetType: "w/widget-type" })
+ * squatch.widgets().upsertUser({ user: { ... }, widgetType: "w/widget-type" })
+ * squatch.widgets().autofill(".referral-code")
+ */
+
+function widgets() {
+  if (!_widgets) init({});
+  return _widgets;
+}
+/**
+ * A static instance of the {@link EventsApi} created when you call {@link #init init}.
+ *
+ * Read the {@link EventsApi} docs.
+ *
+ * @returns EventsApi static instance
+ *
+ * @example
+ * squatch.events().track({ ... })
+ */
+
+function events() {
+  if (!_events) init({});
+  return _events;
+}
+/**
+ * Entry-point for high level API to render a widget using the instance of {@link Widgets} created when you call {@link #init init}.
+ *
+ * Read the {@link Widgets.render} docs.
+ *
+ * @example
+ * squatch.widget().then(res => {
+ *   const widget = res.widget
+ * }).catch(e => console.error("Did not render widget:", e))
+ */
+
+function widget(widgetConfig) {
+  var _widgets2;
+
+  return (_widgets2 = widgets()) == null ? void 0 : _widgets2.render(widgetConfig);
+}
+/**
+ * Extracts widget configuration from `_saasquatchExtra` UTM parameter. Initialises `squatch` and renders the widget as a {@link PopupWidget} via static instanct of {@link Widgets}.
+ *
+ * Called by default on startup via the loader script.
+ * @private
+ */
+
+function _auto(configIn) {
+  var configs = _getAutoConfig(configIn);
+
+  if (configs) {
+    var _widgets3;
+
+    var {
+      squatchConfig,
+      widgetConfig
+    } = configs;
+    init(squatchConfig);
+    return (_widgets3 = widgets()) == null ? void 0 : _widgets3.render(widgetConfig);
+  }
+}
+/**
+ * Initializes the static `squatch` global. This sets up:
+ *
+ *  - `squatch.api()` a static instance of the {@link WidgetApi}
+ *  - `squatch.widgets()` a static instance of {@link Widgets}
+ *  - `squatch.events()` a static instance of {@link EventsApi}
+ *
+ * @param config Configuration details
+ *
+ * @example
+ * squatch.init({
+ *   tenantAlias:'test_basbtabstq51v',
+ * });
+ */
+
+function init(configIn) {
+  var raw = configIn;
+  var config = validateConfig(raw);
+
+  if (config.tenantAlias.match("^test") || config.debug) {
+    debug.debug.enable("squatch-js*");
+  } else {
+    debug.debug.disable();
+  }
+
+  _log("initializing ...");
+
+  _api = new WidgetApi(config);
+  _widgets = new Widgets(config);
+  _events = new EventsApi(config);
+
+  _log("Widget API instance", _api);
+
+  _log("Widgets instance", _widgets);
+
+  _log("Events API instance", _events);
+}
+/**
+ * Squatch.js can't start safely making operations until it's "ready". This
+ * function detects that state.
+ *
+ * @param fn A callback once Squatch.js is ready.
+ *
+ * @example
+ * squatch.ready(function() {
+ *   console.log("ready!");
+ *   squatch.api().upsertUser({ ... });
+ * });
+ */
+
+function ready(fn) {
+  fn();
+}
+/**
+ * Autofills a referral code into an element when someone has been referred.
+ * Uses {@link WidgetApi.squatchReferralCookie} behind the scenes.
+ *
+ * @param {string} selector Element class/id
+ * @returns {void}
+ *
+ * @example
+ * squatch.autofill("input.referral-code")
+ * squatch.autofill("input#referral-code")
+ */
+
+function autofill(selector) {
+  // @ts-ignore -- will throw occasionally throw a null pointer exception at runtime
+  widgets().autofill(selector);
+}
+/**
+ * Manually set the _saasquatch cookie as a 1st party cookie if available as a URL parameter on the current page.
+ * This runs automatically immediately when squatch-js is loaded, except when window.SaaSquatchDoNotAutoDrop is true.
+ * Use this function manually if you have a single page application or custom routing that causes the `_saasquatch` URL parameter to not be set when Squatch.js loads.
+ 
+ * It is safe to run this function multiple times. If the `_saasquatch` URL parameter is invalid or missing it will not clear the 1st party cookie.
+ 
+ *
+ * @returns {void}
+ *
+ * @example
+ * squatch.pushCookie();
+ */
+
+function pushCookie() {
+  _pushCookie();
+}
+
+if (typeof document !== "undefined" && !window.SaaSquatchDoNotAutoDrop) {
+  pushCookie();
+} // Show message if squatchjs has already been loaded on the page
+
+
+if ((_window$squatch = window["squatch"]) != null && _window$squatch.init) _log("Squatchjs is being loaded more than once. This may lead to multiple load events being sent, duplicated widgets, and inaccurate analytics.");
+if (typeof document !== "undefined") asyncLoad();
+
+exports.DeclarativeEmbedWidget = DeclarativeEmbedWidget;
+exports.DeclarativePopupWidget = DeclarativePopupWidget;
+exports.EmbedWidget = EmbedWidget;
+exports.PopupWidget = PopupWidget;
+exports.WidgetApi = WidgetApi;
+exports.Widgets = Widgets;
+exports._auto = _auto;
+exports.api = api;
+exports.autofill = autofill;
+exports.events = events;
+exports.help = help;
+exports.init = init;
+exports.pushCookie = pushCookie;
+exports.ready = ready;
+exports.widget = widget;
+exports.widgets = widgets;
+//# sourceMappingURL=squatch.js.map