@saasquatch/squatch-js 2.7.0-2 → 2.7.0-4

package/dist/squatch.esm.js

@@ -0,0 +1,2161 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var browser = { exports: {} };
+var ms;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms;
+  hasRequiredMs = 1;
+  var s = 1e3;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      str
+    );
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return Math.round(ms2 / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms2 / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms2 / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms2 / s) + "s";
+    }
+    return ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return plural(ms2, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms2, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms2, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms2, msAbs, s, "second");
+    }
+    return ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms;
+}
+var common;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = requireMs();
+    Object.keys(env).forEach(function(key) {
+      createDebug[key] = env[key];
+    });
+    createDebug.instances = [];
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      var hash = 0;
+      for (var i = 0; i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      var prevTime;
+      function debug2() {
+        if (!debug2.enabled) {
+          return;
+        }
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var self = debug2;
+        var curr = Number(/* @__PURE__ */ new Date());
+        var ms2 = curr - (prevTime || curr);
+        self.diff = ms2;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        var index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+          if (match === "%%") {
+            return match;
+          }
+          index++;
+          var formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            var val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        var logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug2.namespace = namespace;
+      debug2.enabled = createDebug.enabled(namespace);
+      debug2.useColors = createDebug.useColors();
+      debug2.color = selectColor(namespace);
+      debug2.destroy = destroy;
+      debug2.extend = extend;
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug2);
+      }
+      createDebug.instances.push(debug2);
+      return debug2;
+    }
+    function destroy() {
+      var index = createDebug.instances.indexOf(this);
+      if (index !== -1) {
+        createDebug.instances.splice(index, 1);
+        return true;
+      }
+      return false;
+    }
+    function extend(namespace, delimiter) {
+      return createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.names = [];
+      createDebug.skips = [];
+      var i;
+      var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+      var len = split.length;
+      for (i = 0; i < len; i++) {
+        if (!split[i]) {
+          continue;
+        }
+        namespaces = split[i].replace(/\*/g, ".*?");
+        if (namespaces[0] === "-") {
+          createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+        } else {
+          createDebug.names.push(new RegExp("^" + namespaces + "$"));
+        }
+      }
+      for (i = 0; i < createDebug.instances.length; i++) {
+        var instance = createDebug.instances[i];
+        instance.enabled = createDebug.enabled(instance.namespace);
+      }
+    }
+    function disable() {
+      createDebug.enable("");
+    }
+    function enabled(name) {
+      if (name[name.length - 1] === "*") {
+        return true;
+      }
+      var i;
+      var len;
+      for (i = 0, len = createDebug.skips.length; i < len; i++) {
+        if (createDebug.skips[i].test(name)) {
+          return false;
+        }
+      }
+      for (i = 0, len = createDebug.names.length; i < len; i++) {
+        if (createDebug.names[i].test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  common = setup;
+  return common;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  (function(module, exports) {
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.colors = ["#0000CC", "#0000FF", "#0033CC", "#0033FF", "#0066CC", "#0066FF", "#0099CC", "#0099FF", "#00CC00", "#00CC33", "#00CC66", "#00CC99", "#00CCCC", "#00CCFF", "#3300CC", "#3300FF", "#3333CC", "#3333FF", "#3366CC", "#3366FF", "#3399CC", "#3399FF", "#33CC00", "#33CC33", "#33CC66", "#33CC99", "#33CCCC", "#33CCFF", "#6600CC", "#6600FF", "#6633CC", "#6633FF", "#66CC00", "#66CC33", "#9900CC", "#9900FF", "#9933CC", "#9933FF", "#99CC00", "#99CC33", "#CC0000", "#CC0033", "#CC0066", "#CC0099", "#CC00CC", "#CC00FF", "#CC3300", "#CC3333", "#CC3366", "#CC3399", "#CC33CC", "#CC33FF", "#CC6600", "#CC6633", "#CC9900", "#CC9933", "#CCCC00", "#CCCC33", "#FF0000", "#FF0033", "#FF0066", "#FF0099", "#FF00CC", "#FF00FF", "#FF3300", "#FF3333", "#FF3366", "#FF3399", "#FF33CC", "#FF33FF", "#FF6600", "#FF6633", "#FF9900", "#FF9933", "#FFCC00", "#FFCC33"];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      var c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      var index = 0;
+      var lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, function(match) {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    function log() {
+      var _console;
+      return (typeof console === "undefined" ? "undefined" : _typeof(console)) === "object" && console.log && (_console = console).log.apply(_console, arguments);
+    }
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      var r;
+      try {
+        r = exports.storage.getItem("debug");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = requireCommon()(exports);
+    var formatters = module.exports.formatters;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  })(browser, browser.exports);
+  return browser.exports;
+}
+var browserExports = requireBrowser();
+const debug = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
+/*! js-cookie v3.0.5 | MIT */
+function assign(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+var defaultConverter = {
+  read: function(value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+  write: function(value) {
+    return encodeURIComponent(value).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    );
+  }
+};
+function init$1(converter, defaultAttributes) {
+  function set(name, value, attributes) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    attributes = assign({}, defaultAttributes, attributes);
+    if (typeof attributes.expires === "number") {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+    }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+    name = encodeURIComponent(name).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+    var stringifiedAttributes = "";
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue;
+      }
+      stringifiedAttributes += "; " + attributeName;
+      if (attributes[attributeName] === true) {
+        continue;
+      }
+      stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
+    }
+    return document.cookie = name + "=" + converter.write(value, name) + stringifiedAttributes;
+  }
+  function get(name) {
+    if (typeof document === "undefined" || arguments.length && !name) {
+      return;
+    }
+    var cookies = document.cookie ? document.cookie.split("; ") : [];
+    var jar = {};
+    for (var i = 0; i < cookies.length; i++) {
+      var parts = cookies[i].split("=");
+      var value = parts.slice(1).join("=");
+      try {
+        var found = decodeURIComponent(parts[0]);
+        jar[found] = converter.read(value, found);
+        if (name === found) {
+          break;
+        }
+      } catch (e) {
+      }
+    }
+    return name ? jar[name] : jar;
+  }
+  return Object.create(
+    {
+      set,
+      get,
+      remove: function(name, attributes) {
+        set(
+          name,
+          "",
+          assign({}, attributes, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function(attributes) {
+        return init$1(this.converter, assign({}, this.attributes, attributes));
+      },
+      withConverter: function(converter2) {
+        return init$1(assign({}, this.converter, converter2), this.attributes);
+      }
+    },
+    {
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
+    }
+  );
+}
+var api$1 = init$1(defaultConverter, { path: "/" });
+const DEFAULT_DOMAIN = "https://app.referralsaasquatch.com";
+const DEFAULT_NPM_CDN = "https://fast.ssqt.io/npm";
+const DEFAULT_NAMESPACE = "squatch";
+const IMPACT_NAMESPACE = "impact";
+function validateConfig(_raw) {
+  if (typeof _raw !== "object") throw new Error("config must be an object");
+  const tenant = window.squatchTenant;
+  const config = getConfig();
+  const 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");
+  const tenantAlias = raw.tenantAlias;
+  const domain = typeof raw.domain === "string" && raw.domain || DEFAULT_DOMAIN;
+  const debug2 = typeof raw.debug === "boolean" && raw.debug || false;
+  const npmCdn = typeof raw.npmCdn === "string" && raw.npmCdn || DEFAULT_NPM_CDN;
+  return {
+    tenantAlias,
+    domain,
+    debug: debug2,
+    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 ? void 0 : 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;
+}
+browserExports.debug("squatch-js:io");
+async function doQuery(url, query, variables, jwt) {
+  const token = jwt || getToken();
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    ...token ? { Authorization: `Bearer ${token}` } : {},
+    "X-SaaSquatch-Referrer": window ? window.location.href : ""
+  };
+  try {
+    const 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 = "") {
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  const token = jwt || getToken();
+  if (token) headers["X-SaaSquatch-User-Token"] = token;
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      credentials: "include",
+      headers
+    });
+    const 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) {
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  const token = jwt || getToken();
+  if (token) headers["X-SaaSquatch-User-Token"] = token;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      body: data,
+      headers
+    });
+    const 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) {
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "X-SaaSquatch-Referrer": window ? window.location.href : ""
+  };
+  const token = jwt || getToken();
+  if (token) headers["X-SaaSquatch-User-Token"] = token;
+  try {
+    const res = await fetch(url, {
+      headers,
+      method: "PUT",
+      credentials: "include",
+      body: data
+    });
+    const reply = await res.text();
+    if (!res.ok) throw new Error(reply);
+    return reply ? JSON.parse(reply) : reply;
+  } catch (e) {
+    throw e;
+  }
+}
+const RENDER_WIDGET_QUERY = `
+  query renderWidget ($user: UserIdInput, $engagementMedium: UserEngagementMedium, $widgetType: WidgetType, $locale: RSLocale) {
+    renderWidget(user: $user, engagementMedium: $engagementMedium, widgetType: $widgetType, locale: $locale) {
+      template
+      user {
+        id
+        accountId
+      }
+      jsOptions
+      widgetConfig {
+        values
+      }
+    }
+  }
+`;
+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) {
+    __publicField(this, "tenantAlias");
+    __publicField(this, "domain");
+    __publicField(this, "npmCdn");
+    __publicField(this, "referralCookie", this.squatchReferralCookie);
+    const raw = config;
+    const 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) {
+    const raw = params;
+    const clean = validateWidgetConfig(raw);
+    const {
+      widgetType,
+      engagementMedium = "POPUP",
+      jwt,
+      locale,
+      user
+    } = clean;
+    const tenantAlias = encodeURIComponent(this.tenantAlias);
+    const accountId = user.accountId ? encodeURIComponent(user.accountId) : null;
+    const userId = user.id ? encodeURIComponent(user.id) : null;
+    const optionalParams = _buildParams({
+      widgetType,
+      engagementMedium,
+      locale
+    });
+    const path = `/api/v1/${tenantAlias}/widget/account/${accountId}/user/${userId}/upsert${optionalParams}`;
+    const url = this.domain + path;
+    const cookies = (api$1 || 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) {
+    const raw = params;
+    const clean = validatePasswordlessConfig(raw);
+    const { widgetType, engagementMedium = "POPUP", jwt, user } = clean;
+    const tenantAlias = encodeURIComponent(this.tenantAlias);
+    const accountId = (user == null ? void 0 : user.accountId) ? encodeURIComponent(user.accountId) : null;
+    const userId = (user == null ? void 0 : user.id) ? encodeURIComponent(user.id) : null;
+    const locale = clean.locale ?? validateLocale(navigator.language.replace(/\-/g, "_"));
+    const path = `/api/v1/${tenantAlias}/graphql`;
+    const url = this.domain + path;
+    return new Promise(async (resolve, reject) => {
+      var _a2;
+      try {
+        const res = await doQuery(
+          url,
+          RENDER_WIDGET_QUERY,
+          {
+            user: userId && accountId ? { id: userId, accountId } : null,
+            engagementMedium,
+            widgetType,
+            locale
+          },
+          jwt
+        );
+        resolve((_a2 = res == null ? void 0 : res.data) == null ? void 0 : _a2.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() {
+    const tenantAlias = encodeURIComponent(this.tenantAlias);
+    const _saasquatch = (api$1 || window.Cookies).get("_saasquatch") || "";
+    const cookie = _saasquatch ? `?cookies=${encodeURIComponent(_saasquatch)}` : ``;
+    const url = `${this.domain}/a/${tenantAlias}/widgets/squatchcookiejson${cookie}`;
+    const response = await doGet(url);
+    return Promise.resolve({
+      ...response,
+      encodedCookie: _saasquatch
+    });
+  }
+}
+function _buildParams({
+  widgetType,
+  engagementMedium,
+  locale
+}) {
+  const queryParams = new URLSearchParams();
+  queryParams.append("engagementMedium", engagementMedium);
+  if (widgetType) queryParams.append("widgetType", widgetType);
+  if (locale) queryParams.append("locale", locale);
+  return `?${queryParams.toString()}`;
+}
+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) {
+    __publicField(this, "domain");
+    var _a2;
+    const raw = config;
+    const clean = _validateAnalyticsConfig(raw);
+    this.domain = (clean == null ? void 0 : clean["domain"]) || ((_a2 = getConfig()) == null ? void 0 : _a2.domain) || DEFAULT_DOMAIN;
+  }
+  pushAnalyticsLoadEvent(params) {
+    if (!params.externalUserId || !params.externalAccountId) return;
+    const tenantAlias = encodeURIComponent(params.tenantAlias);
+    const accountId = encodeURIComponent(params.externalAccountId);
+    const userId = encodeURIComponent(params.externalUserId);
+    const engagementMedium = encodeURIComponent(params.engagementMedium);
+    const programId = params.programId ? `&programId=${encodeURIComponent(params.programId)}` : ``;
+    const path = `/a/${tenantAlias}/widgets/analytics/loaded?externalAccountId=${accountId}&externalUserId=${userId}&engagementMedium=${engagementMedium}${programId}`;
+    const url = this.domain + path;
+    return doPost(url, JSON.stringify({}));
+  }
+  pushAnalyticsShareClickedEvent(params) {
+    const tenantAlias = encodeURIComponent(params.tenantAlias);
+    const accountId = encodeURIComponent(params.externalAccountId);
+    const userId = encodeURIComponent(params.externalUserId);
+    const engagementMedium = encodeURIComponent(params.engagementMedium);
+    const shareMedium = encodeURIComponent(params.shareMedium);
+    const path = `/a/${tenantAlias}/widgets/analytics/shared?externalAccountId=${accountId}&externalUserId=${userId}&engagementMedium=${engagementMedium}&shareMedium=${shareMedium}`;
+    const 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;
+}
+const _log$8 = browserExports.debug("squatch-js:widget");
+class Widget {
+  constructor(params) {
+    __publicField(this, "type");
+    __publicField(this, "content");
+    __publicField(this, "analyticsApi");
+    __publicField(this, "widgetApi");
+    __publicField(this, "context");
+    __publicField(this, "npmCdn");
+    __publicField(this, "container");
+    __publicField(this, "loadEventListener", null);
+    var _a2;
+    _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 = ((_a2 = params.context) == null ? void 0 : _a2.container) || params.container;
+  }
+  _findElement() {
+    let element;
+    if (typeof this.container === "string") {
+      element = document.querySelector(this.container);
+      _log$8("loading widget with selector", element);
+    } else if (this.container instanceof HTMLElement) {
+      element = this.container;
+      _log$8("loading widget with container", element);
+    } else if (this.container) {
+      element = null;
+      _log$8("container must be an HTMLElement or string", this.container);
+    } 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() {
+    const 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() {
+    const element = this.container ? this._findElement() : document.body;
+    const 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({
+          ...sqh,
+          userId: e.detail.userId,
+          accountId: e.detail.accountId
+        });
+      };
+      frameDoc.addEventListener("sq:user-registration", this.loadEventListener);
+    }
+  }
+  _loadEvent(sqh) {
+    var _a2;
+    if (!sqh) return;
+    if (!isObject$1(sqh)) {
+      throw new Error("Widget Load event identity property is not an object");
+    }
+    let 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 {
+      const { analytics, mode } = sqh;
+      params = {
+        tenantAlias: analytics.attributes.tenant,
+        externalAccountId: analytics.attributes.accountId,
+        externalUserId: analytics.attributes.userId,
+        engagementMedium: mode.widgetMode
+      };
+    }
+    (_a2 = this.analyticsApi.pushAnalyticsLoadEvent(params)) == null ? void 0 : _a2.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 = "modal", style = "") {
+    const errorTemplate = `<!DOCTYPE html>
+    <!--[if IE 7]><html class="ie7 oldie" lang="en"><![endif]-->
+    <!--[if IE 8]><html class="ie8 oldie" lang="en"><![endif]-->
+    <!--[if gt IE 8]><!--><html lang="en"><!--<![endif]-->
+    <head>
+      <link rel="stylesheet" media="all" href="https://fast.ssqt.io/assets/css/widget/errorpage.css">
+      <style>
+        ${style}
+      </style>
+    </head>
+    <body>
+
+      <div class="squatch-container ${mode}" style="width:100%">
+        <div class="errorheader">
+          <button type="button" class="close" onclick="window.frameElement.squatchJsApi.close();">&times;</button>
+          <p class="errortitle">Error</p>
+        </div>
+        <div class="errorbody">
+          <div class="sadface"><img src="https://fast.ssqt.io/assets/images/face.png"></div>
+          <h4>Our referral program is temporarily unavailable.</h4><br>
+          <p>Please reload the page or check back later.</p>
+          <p>If the persists please contact our support team.</p>
+          <br>
+          <br>
+          <div class="right-align errtxt">
+            Error Code: ${rs}
+          </div>
+        </div>
+      </div>
+    </body>
+    </html>`;
+    return errorTemplate;
+  }
+  async _findInnerContainer(frame) {
+    const { contentWindow } = frame;
+    if (!contentWindow)
+      throw new Error("Squatch.js frame inner frame is empty");
+    const frameDoc = contentWindow.document;
+    function search() {
+      const containers = frameDoc.getElementsByTagName("sqh-global-container");
+      const legacyContainers = frameDoc.getElementsByClassName("squatch-container");
+      const fallback = containers.length > 0 ? containers[0] : legacyContainers.length > 0 ? legacyContainers[0] : null;
+      return fallback;
+    }
+    let found = null;
+    for (let 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({ email, firstName, lastName }, jwt) {
+    const frame = this._findFrame();
+    if (!frame) throw new Error("Could not find widget iframe");
+    const frameWindow = frame.contentWindow;
+    const engagementMedium = this.context.engagementMedium || "POPUP";
+    if (!frameWindow) {
+      throw new Error("Frame needs a content window");
+    }
+    let response;
+    if (this.context.type === "upsert") {
+      if (!this.context.user) throw new Error("Can't reload without user ids");
+      let 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: void 0,
+        engagementMedium,
+        widgetType: this.type,
+        jwt: void 0
+      });
+    } else {
+      throw new Error("can't reload an error widget");
+    }
+    response.then(({ template }) => {
+      if (template) {
+        this.content = template;
+        this.__deprecated__register(
+          frame,
+          { email, engagementMedium },
+          () => {
+            this.load();
+            engagementMedium === "POPUP" && this.open();
+          }
+        );
+      }
+    }).catch(({ message }) => {
+      _log$8(`${message}`);
+    });
+  }
+  __deprecated__register(frame, params, onClick) {
+    const frameWindow = frame.contentWindow;
+    const frameDoc = frameWindow.document;
+    const showStatsBtn = frameDoc.createElement("button");
+    const 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";
+      const widgetStyle = params.engagementMedium === "POPUP" ? "margin-top: 10px; max-width: 130px; width: 100%;" : "margin-top: 10px;";
+      showStatsBtn.setAttribute("style", widgetStyle);
+      showStatsBtn.onclick = onClick;
+      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) {
+  let fns = [];
+  let listener;
+  let doc = targetDoc;
+  let hack = doc.documentElement.doScroll;
+  let domContentLoaded = "DOMContentLoaded";
+  let 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();
+      }
+    );
+  return loaded ? setTimeout(fn, 0) : fns.push(fn);
+}
+const _log$7 = browserExports.debug("squatch-js:EMBEDwidget");
+class EmbedWidget extends Widget {
+  constructor(params, container) {
+    super(params);
+    __publicField(this, "show", this.open);
+    __publicField(this, "hide", this.close);
+    if (container) this.container = container;
+  }
+  async load() {
+    var _a2, _b;
+    const frame = this._createFrame();
+    const element = this._findElement();
+    if ((_a2 = this.context) == null ? void 0 : _a2.container) {
+      element.style.visibility = "hidden";
+      element.style.height = "0";
+      element.style["overflow-y"] = "hidden";
+    }
+    if (this.container) {
+      if (element.shadowRoot) {
+        if (((_b = element.shadowRoot.lastChild) == null ? void 0 : _b.nodeName) === "IFRAME") {
+          element.shadowRoot.replaceChild(frame, element.shadowRoot.lastChild);
+        } else {
+          element.shadowRoot.appendChild(frame);
+        }
+      } else if (element.firstChild) {
+        element.replaceChild(frame, element.firstChild);
+      } else {
+        element.appendChild(frame);
+      }
+    } else if (!element.firstChild || element.firstChild.nodeName === "#text") {
+      element.appendChild(frame);
+    }
+    const { contentWindow } = frame;
+    if (!contentWindow) {
+      throw new Error("Frame needs a content window");
+    }
+    const 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 () => {
+      const _sqh = contentWindow.squatch || contentWindow.widgetIdent;
+      frame.height = frameDoc.body.scrollHeight;
+      const ro = new contentWindow["ResizeObserver"]((entries) => {
+        for (const entry of entries) {
+          const { height } = entry.contentRect;
+          frame.height = height;
+        }
+      });
+      const 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() {
+    const frame = this._findFrame();
+    if (!frame) return _log$7("no target element to open");
+    if (!frame.contentWindow) return _log$7("Frame needs a content window");
+    const element = this._findElement();
+    element.style.visibility = "unset";
+    element.style.height = "auto";
+    element.style["overflow-y"] = "auto";
+    frame.contentWindow.document.dispatchEvent(new CustomEvent("sq:refresh"));
+    const _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() {
+    const frame = this._findFrame();
+    if (!frame) return _log$7("no target element to close");
+    if (frame.contentDocument)
+      this._detachLoadEventListener(frame.contentDocument);
+    const element = this._findElement();
+    element.style.visibility = "hidden";
+    element.style.height = "0";
+    element.style["overflow-y"] = "hidden";
+    _log$7("Embed widget closed");
+  }
+  _error(rs, mode = "embed", style = "") {
+    return super._error(rs, mode, style);
+  }
+  _shouldFireLoadEvent() {
+    const noContainer = !this.container;
+    const isComponent = this.container instanceof HTMLElement && (this.container.tagName.startsWith("SQUATCH-") || this.container.tagName.startsWith("IMPACT-"));
+    const isVerified = !!this.context.user;
+    return isVerified && (noContainer || isComponent);
+  }
+}
+const _log$6 = browserExports.debug("squatch-js:POPUPwidget");
+let popupId = 0;
+class PopupWidget extends Widget {
+  constructor(params, trigger = ".squatchpop") {
+    super(params);
+    __publicField(this, "trigger");
+    __publicField(this, "id");
+    __publicField(this, "show", this.open);
+    __publicField(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;
+    let triggerElement;
+    try {
+      triggerElement = document.querySelector(this.trigger) || document.querySelector(".impactpop");
+      if (this.trigger && !triggerElement)
+        _log$6("No element found with trigger selector", this.trigger);
+    } catch {
+      _log$6("Not a valid selector", this.trigger);
+    }
+    if (triggerElement) {
+      triggerElement.onclick = () => {
+        this.open();
+      };
+    }
+  }
+  _createPopupDialog() {
+    const dialog = document.createElement("dialog");
+    dialog.id = this.id;
+    dialog.setAttribute(
+      "style",
+      "width: 100%; max-width: 500px; border: none; padding: 0;"
+    );
+    const onClick = (e) => {
+      e.stopPropagation();
+      if (e.target === dialog) dialog.close();
+    };
+    dialog.addEventListener("click", onClick);
+    return dialog;
+  }
+  async load() {
+    var _a2;
+    const frame = this._createFrame();
+    this._initialiseCTA();
+    const element = this.container ? this._findElement() : document.body;
+    const dialogParent = element.shadowRoot || element;
+    const dialog = this._createPopupDialog();
+    dialog.appendChild(frame);
+    if (((_a2 = dialogParent.lastChild) == null ? void 0 : _a2.nodeName) === "DIALOG") {
+      dialogParent.replaceChild(dialog, dialogParent.lastChild);
+    } else {
+      dialogParent.appendChild(dialog);
+    }
+    const { contentWindow } = frame;
+    if (!contentWindow) {
+      throw new Error("Frame needs a content window");
+    }
+    const 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) {
+    const { contentWindow } = frame;
+    if (!contentWindow) {
+      throw new Error("Frame needs a content window");
+    }
+    const frameDoc = contentWindow.document;
+    domready(frameDoc, async () => {
+      frameDoc.body.style.overflowY = "hidden";
+      frame.height = `${frameDoc.body.offsetHeight}px`;
+      const ro = new contentWindow["ResizeObserver"]((entries) => {
+        for (const entry of entries) {
+          const { top, bottom } = entry.contentRect;
+          const computedHeight = bottom + top;
+          frame.height = computedHeight + "";
+          entry.target.style = ``;
+        }
+      });
+      ro.observe(await this._findInnerContainer(frame));
+    });
+  }
+  open() {
+    const element = this.container ? this._findElement() : document.body;
+    const parent = element.shadowRoot || element;
+    const dialog = parent.querySelector(`#${this.id}`);
+    if (!dialog) throw new Error("Could not determine container div");
+    dialog.showModal();
+    const frame = this._findFrame();
+    if (!frame) throw new Error("Could not find iframe");
+    const { contentWindow } = frame;
+    if (!contentWindow) throw new Error("Squatch.js has an empty iframe");
+    const frameDoc = contentWindow.document;
+    domready(frameDoc, () => {
+      var _a2;
+      const _sqh = contentWindow.squatch || contentWindow.widgetIdent;
+      (_a2 = frame.contentDocument) == null ? void 0 : _a2.dispatchEvent(new CustomEvent("sq:refresh"));
+      if (this.context.user) {
+        this._loadEvent(_sqh);
+        _log$6("Popup opened");
+      } else {
+        this._attachLoadEventListener(frameDoc, _sqh);
+      }
+    });
+  }
+  close() {
+    const frame = this._findFrame();
+    if (frame == null ? void 0 : frame.contentDocument)
+      this._detachLoadEventListener(frame.contentDocument);
+    const element = this.container ? this._findElement() : document.body;
+    const parent = element.shadowRoot || element;
+    const dialog = parent.querySelector(`#${this.id}`);
+    if (!dialog) throw new Error("Could not determine container div");
+    dialog.close();
+    _log$6("Popup closed");
+  }
+  _clickedOutside({ target }) {
+  }
+  _error(rs, mode = "modal", style = "") {
+    const _style = "body { margin: 0; } .modal { box-shadow: none; border: 0; }";
+    return super._error(rs, mode, style || _style);
+  }
+}
+const _log$5 = browserExports.debug("squatch-js:widgets");
+class Widgets {
+  /**
+   * 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) {
+    /**
+     * Instance of {@link WidgetApi}
+     */
+    __publicField(this, "api");
+    /**
+     * Tenant alias of SaaSquatch tenant
+     */
+    __publicField(this, "tenantAlias");
+    /**
+     * SaaSquatch domain for API requests
+     * @default "https://app.referralsaasquatch.com"
+     */
+    __publicField(this, "domain");
+    /**
+     * Hosted CDN for npm packages
+     * @default "https://fast.ssqt.io/npm"
+     */
+    __publicField(this, "npmCdn");
+    const 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) {
+    const raw = config;
+    const clean = validateWidgetConfig(raw);
+    try {
+      const 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) {
+    const raw = config;
+    const clean = validatePasswordlessConfig(raw);
+    try {
+      const 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) {
+    const input = selector;
+    if (typeof input === "function") {
+      try {
+        const 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");
+    let elems = document.querySelectorAll(input);
+    let elem;
+    if (elems.length > 0) {
+      elem = elems[0];
+    } else {
+      _log$5("Element id/class or function missing");
+      throw new Error("Element id/class or function missing");
+    }
+    try {
+      const 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 _a2;
+    _log$5("Rendering Widget...");
+    if (!response) throw new Error("Unable to get a response");
+    let widget2;
+    let displayOnLoad = !!config.displayOnLoad;
+    const opts = response.jsOptions || {};
+    const params = {
+      content: response.template,
+      type: config.widgetType || ((_a2 = opts.widget) == null ? void 0 : _a2.defaultWidgetType),
+      api: this.api,
+      domain: this.domain,
+      npmCdn: this.npmCdn,
+      context
+    };
+    if (opts.widgetUrlMappings) {
+      opts.widgetUrlMappings.forEach((rule) => {
+        var _a3, _b;
+        if (Widgets._matchesUrl(rule.url)) {
+          if (rule.widgetType !== "CONVERSION_WIDGET" || ((_b = (_a3 = response.user) == null ? void 0 : _a3.referredBy) == null ? void 0 : _b.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(({ url, formSelector }) => {
+        var _a3, _b, _c;
+        if (Widgets._matchesUrl(url)) {
+          _log$5("Fuel Tank URL matches");
+          if ((_b = (_a3 = response.user) == null ? void 0 : _a3.referredBy) == null ? void 0 : _b.code) {
+            const formAutofill = document.querySelector(formSelector);
+            if (formAutofill) {
+              formAutofill.value = ((_c = response.user.referredBy.referredReward) == null ? void 0 : _c.fuelTankCode) || "";
+            } else {
+              _log$5(
+                new Error(
+                  `Element with id/class ${formSelector} was not found.`
+                )
+              );
+            }
+          }
+        }
+      });
+    }
+    if (config.engagementMedium === "EMBED") {
+      widget2 = this._renderEmbedWidget(params);
+    } else {
+      widget2 = this._renderPopupWidget(params);
+      if (displayOnLoad) widget2.open();
+    }
+    return widget2;
+  }
+  _renderPopupWidget(params) {
+    const widget2 = new PopupWidget(params, params.context.trigger);
+    widget2.load();
+    return widget2;
+  }
+  _renderEmbedWidget(params) {
+    const widget2 = new EmbedWidget(params, params.context.container);
+    widget2.load();
+    return widget2;
+  }
+  /**
+   * @hidden
+   * @param {Object} error The json object containing the error details
+   * @param {string} em The engagementMedium
+   * @returns {void}
+   */
+  _renderErrorWidget(props, em = "POPUP") {
+    const { apiErrorCode, rsCode, message } = props;
+    _log$5(new Error(`${apiErrorCode} (${rsCode}) ${message}`));
+    const params = {
+      content: "error",
+      rsCode,
+      api: this.api,
+      domain: this.domain,
+      npmCdn: this.npmCdn,
+      type: "ERROR_WIDGET",
+      context: { type: "error" }
+    };
+    let widget2;
+    if (em === "EMBED") {
+      widget2 = new EmbedWidget(params);
+      widget2.load();
+    } else if (em === "POPUP") {
+      widget2 = new PopupWidget(params);
+      widget2.load();
+    }
+  }
+  /**
+   * @hidden
+   * @param {string} rule A regular expression
+   * @returns {boolean} true if rule matches Url, false otherwise
+   */
+  static _matchesUrl(rule) {
+    return window.location.href.match(new RegExp(rule)) ? true : false;
+  }
+}
+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) {
+    __publicField(this, "tenantAlias");
+    __publicField(this, "domain");
+    const raw = config;
+    const 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) {
+    const raw = params;
+    const rawOpts = options;
+    const body = _validateEvent(raw);
+    const { jwt } = _validateTrackOptions(rawOpts);
+    const ta = encodeURIComponent(this.tenantAlias);
+    const userId = encodeURIComponent(body.userId);
+    const accountId = encodeURIComponent(body.accountId);
+    const path = `/api/v1/${ta}/open/account/${accountId}/user/${userId}/events`;
+    const 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 ? void 0 : raw["accountId"])) throw new Error("accountId field is required");
+  if (!(raw == null ? void 0 : raw["events"])) throw new Error("events field is required");
+  if (!(raw == null ? void 0 : raw["userId"])) throw new Error("userId field is required");
+  const 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;
+}
+function asyncLoad() {
+  var _a2;
+  const namespace = window[IMPACT_NAMESPACE] ? IMPACT_NAMESPACE : DEFAULT_NAMESPACE;
+  const cached = ((_a2 = window["_" + namespace]) == null ? void 0 : _a2.ready) || [];
+  const declarativeCache = window.impactOnReady || window.squatchOnReady;
+  const readyFns = [...cached, declarativeCache].filter((a) => !!a);
+  setTimeout(() => {
+    if (!window[DEFAULT_NAMESPACE]) return;
+    window[IMPACT_NAMESPACE] = window[DEFAULT_NAMESPACE];
+    readyFns.forEach((cb) => cb());
+    window[DEFAULT_NAMESPACE]._auto();
+    window["_" + namespace] = void 0;
+    delete window["_" + namespace];
+  }, 0);
+}
+const _log$4 = browserExports.debug("squatch-js");
+const isObject = (item) => typeof item === "object" && !Array.isArray(item);
+const deepMerge = (target, source) => {
+  const isDeep = (prop) => isObject(source[prop]) && target.hasOwnProperty(prop) && isObject(target[prop]);
+  const replaced = Object.getOwnPropertyNames(source).map((prop) => ({
+    [prop]: isDeep(prop) ? deepMerge(target[prop], source[prop]) : source[prop]
+  })).reduce((a, b) => ({ ...a, ...b }), {});
+  return {
+    ...target,
+    ...replaced
+  };
+};
+function b64decode(input) {
+  const binary = atob(input.replace(/_/g, "/").replace(/-/g, "+"));
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder("utf8").decode(bytes);
+}
+function b64encode(input) {
+  const encodedInput = new TextEncoder().encode(input);
+  const binary = Array.from(
+    encodedInput,
+    (byte) => String.fromCodePoint(byte)
+  ).join("");
+  return btoa(binary).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+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) {
+      document.cookie = weird_cookie.split("=")[0] + "=;domain=." + h + ";expires=Thu, 01 Jan 1970 00:00:01 GMT;";
+      return h;
+    }
+  }
+}
+function _pushCookie() {
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  const refParam = urlParams.get("_saasquatch") || "";
+  if (refParam) {
+    let paramsJSON = "", existingCookie = "", reEncodedCookie = "";
+    try {
+      paramsJSON = JSON.parse(b64decode(refParam));
+    } catch (error) {
+      _log$4("Unable to decode params", error);
+      return;
+    }
+    try {
+      existingCookie = JSON.parse(b64decode(api$1.get("_saasquatch")));
+      _log$4("existing cookie", existingCookie);
+    } catch (error) {
+      _log$4("Unable to retrieve cookie", error);
+    }
+    try {
+      const domain = getTopDomain();
+      _log$4("domain retrieved:", domain);
+      if (existingCookie) {
+        const 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);
+      }
+      api$1.set("_saasquatch", reEncodedCookie, {
+        expires: 365,
+        secure: false,
+        sameSite: "Lax",
+        domain,
+        path: "/"
+      });
+    } catch (error) {
+      _log$4("Unable to set cookie", error);
+    }
+  }
+}
+const _log$3 = browserExports.debug("squatch-js");
+function _getAutoConfig(configIn) {
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  const refParam = urlParams.get("_saasquatchExtra") || "";
+  if (!refParam) {
+    _log$3("No _saasquatchExtra param");
+    return;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(b64decode(refParam));
+  } catch (e) {
+    _log$3("Unable to decode _saasquatchExtra config");
+    return;
+  }
+  const { domain, tenantAlias, widgetConfig } = convertExtraToConfig(raw);
+  if (!domain || !tenantAlias || !widgetConfig) {
+    _log$3("_saasquatchExtra did not have an expected structure");
+    return void 0;
+  }
+  const { autoPopupWidgetType, ...rest } = widgetConfig;
+  return {
+    widgetConfig: {
+      widgetType: autoPopupWidgetType,
+      displayOnLoad: true,
+      ...rest
+    },
+    squatchConfig: {
+      ...configIn ? { configIn } : {},
+      domain,
+      tenantAlias
+    }
+  };
+}
+function convertExtraToConfig(obj) {
+  var _a2;
+  const _domain = Object.keys(obj || {})[0];
+  const tenantAlias = Object.keys((obj == null ? void 0 : obj[_domain]) || {})[0];
+  const widgetConfig = (_a2 = obj == null ? void 0 : obj[_domain]) == null ? void 0 : _a2[tenantAlias];
+  const domain = _domain ? `https://${_domain}` : void 0;
+  return { domain, tenantAlias, widgetConfig };
+}
+const _log$2 = browserExports.debug("squatch-js:decodeUserJwt");
+function decodeUserJwt(tokenStr) {
+  var _a2;
+  try {
+    const base64Url = tokenStr.split(".")[1];
+    if (base64Url === void 0) return null;
+    const jsonStr = b64decode(base64Url);
+    return (_a2 = JSON.parse(jsonStr)) == null ? void 0 : _a2.user;
+  } catch (e) {
+    _log$2(e);
+    return null;
+  }
+}
+const _log$1 = debug("squatch-js:DeclarativeWidget");
+class DeclarativeWidget extends HTMLElement {
+  constructor() {
+    super();
+    /**
+     * Configuration overrides
+     * @default window.squatchConfig
+     */
+    __publicField(this, "config");
+    /**
+     * Signed JWT containing user information
+     * @default window.squatchToken
+     */
+    __publicField(this, "token");
+    /**
+     * Tenant alias of SaaSquatch tenant
+     * @default window.squatchTenant
+     */
+    __publicField(this, "tenant");
+    /**
+     * widgetType of widget to load
+     */
+    __publicField(this, "widgetType");
+    /**
+     * Locale to render the widget in
+     */
+    __publicField(this, "locale");
+    /**
+     * Instance of {@link WidgetApi}
+     */
+    __publicField(this, "widgetApi");
+    /**
+     * Instance of {@link AnalyticsApi}
+     */
+    __publicField(this, "analyticsApi");
+    /**
+     * Instance of {@link EmbedWidget} or {@link PopupWidget}
+     */
+    __publicField(this, "widgetInstance");
+    /**
+     * Determines whether to render the widget as an embedding widget or popup widget
+     */
+    __publicField(this, "type");
+    /**
+     * Container element to contain the widget iframe
+     * @default this
+     */
+    __publicField(this, "container");
+    __publicField(this, "element");
+    /**
+     * Flag for if the component has been loaded or not
+     * @hidden
+     */
+    __publicField(this, "loaded");
+    __publicField(this, "_setWidget", (template, config) => {
+      var _a2;
+      const params = {
+        api: this.widgetApi,
+        content: template,
+        context: {
+          type: config.type,
+          user: config.user,
+          container: this.container || void 0,
+          engagementMedium: this.type
+        },
+        type: this.widgetType,
+        domain: ((_a2 = this.config) == null ? void 0 : _a2.domain) || DEFAULT_DOMAIN,
+        npmCdn: DEFAULT_NPM_CDN,
+        container: this
+      };
+      if (this.type === "EMBED") {
+        return new EmbedWidget(params);
+      } else {
+        const useFirstChildTrigger = this.firstChild ? null : void 0;
+        return new PopupWidget(params, useFirstChildTrigger);
+      }
+    });
+    /**
+     * Builds a Widget instance for the default error widget
+     * @returns Instance of either {@link EmbedWidget} or {@link PopupWidget} depending on `this.type`
+     */
+    __publicField(this, "setErrorWidget", (e) => {
+      var _a2;
+      const params = {
+        api: this.widgetApi,
+        content: "error",
+        context: {
+          type: "error",
+          container: this.container || void 0
+        },
+        type: "ERROR_WIDGET",
+        domain: ((_a2 = this.config) == null ? void 0 : _a2.domain) || DEFAULT_DOMAIN,
+        npmCdn: DEFAULT_NPM_CDN,
+        container: this
+      };
+      if (this.type === "EMBED") {
+        return new EmbedWidget(params);
+      } else {
+        const useFirstChildTrigger = this.firstChild ? null : void 0;
+        return new PopupWidget(params, useFirstChildTrigger);
+      }
+    });
+    __publicField(this, "reload", this.renderWidget);
+    __publicField(this, "show", this.open);
+    __publicField(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 _a2, _b;
+    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) || ((_a2 = this.config) == null ? void 0 : _a2.domain) || DEFAULT_DOMAIN
+    });
+    this.analyticsApi = new AnalyticsApi({
+      domain: (config == null ? void 0 : config.domain) || ((_b = this.config) == null ? void 0 : _b.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();
+    const userObj = decodeUserJwt(this.token);
+    if (!userObj) {
+      return this.setErrorWidget(Error("No user object in token."));
+    }
+    _log$1("Rendering as a Verified widget");
+    const 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() {
+    let widgetInstance;
+    this.widgetType = this.getAttribute("widget") || void 0;
+    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();
+  }
+  /**
+   * 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();
+  }
+}
+class DeclarativeEmbedWidget extends DeclarativeWidget {
+  constructor() {
+    super();
+    this.type = "EMBED";
+    this.loaded = false;
+  }
+  static get observedAttributes() {
+    return ["widget", "locale"];
+  }
+  attributeChangedCallback(attr, oldVal, newVal) {
+    if (oldVal === newVal || !this.loaded) return;
+    switch (attr) {
+      case "locale":
+      case "widget":
+        this.connectedCallback();
+        break;
+    }
+  }
+  async connectedCallback() {
+    var _a2, _b;
+    this.loaded = true;
+    this.container = this.getAttribute("container");
+    await this.renderWidget();
+    const slot = (_a2 = this.shadowRoot && Array.from(this.shadowRoot.children)) == null ? void 0 : _a2.find((c) => c.tagName === "SLOT");
+    if (slot) (_b = this.shadowRoot) == null ? void 0 : _b.removeChild(slot);
+    if (this.getAttribute("open") !== null) this.open();
+  }
+}
+class DeclarativePopupWidget extends DeclarativeWidget {
+  constructor() {
+    super();
+    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;
+    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);
+function help() {
+  console.log(
+    `Having trouble using Squatch.js? Go to https://docs.referralsaasquatch.com/developer/ for tutorials, references and error codes.`
+  );
+}
+const _log = browserExports.debug("squatch-js");
+let _api = null;
+let _widgets = null;
+let _events = null;
+function api() {
+  if (!_api) init({});
+  return _api;
+}
+function widgets() {
+  if (!_widgets) init({});
+  return _widgets;
+}
+function events() {
+  if (!_events) init({});
+  return _events;
+}
+function widget(widgetConfig) {
+  var _a2;
+  return (_a2 = widgets()) == null ? void 0 : _a2.render(widgetConfig);
+}
+function _auto(configIn) {
+  var _a2;
+  const configs = _getAutoConfig(configIn);
+  if (configs) {
+    const { squatchConfig, widgetConfig } = configs;
+    init(squatchConfig);
+    return (_a2 = widgets()) == null ? void 0 : _a2.render(widgetConfig);
+  }
+}
+function init(configIn) {
+  const raw = configIn;
+  const config = validateConfig(raw);
+  if (config.tenantAlias.match("^test") || config.debug) {
+    browserExports.debug.enable("squatch-js*");
+  } else {
+    browserExports.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);
+}
+function ready(fn) {
+  fn();
+}
+function autofill(selector) {
+  widgets().autofill(selector);
+}
+function pushCookie() {
+  _pushCookie();
+}
+if (typeof document !== "undefined" && !window.SaaSquatchDoNotAutoDrop) {
+  pushCookie();
+}
+if ((_a = window["squatch"]) == null ? void 0 : _a.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();
+export {
+  DeclarativeEmbedWidget,
+  DeclarativePopupWidget,
+  EmbedWidget,
+  PopupWidget,
+  WidgetApi,
+  Widgets,
+  _auto,
+  api,
+  autofill,
+  events,
+  help,
+  init,
+  pushCookie,
+  ready,
+  widget,
+  widgets
+};
+//# sourceMappingURL=squatch.esm.js.map