@mocanetwork/airkit 0.5.0 → 0.6.0-beta.0

package/dist/airkit.umd.js

@@ -0,0 +1,2852 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Airkit = {}));
+})(this, (function (exports) { 'use strict';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+    var extendStatics = function (d, b) {
+      extendStatics = Object.setPrototypeOf || {
+        __proto__: []
+      } instanceof Array && function (d, b) {
+        d.__proto__ = b;
+      } || function (d, b) {
+        for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      };
+      return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+      if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+      extendStatics(d, b);
+      function __() {
+        this.constructor = d;
+      }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function (resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    }
+    function __generator(thisArg, body) {
+      var _ = {
+          label: 0,
+          sent: function () {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+          },
+          trys: [],
+          ops: []
+        },
+        f,
+        y,
+        t,
+        g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+      return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+      }), g;
+      function verb(n) {
+        return function (v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return {
+                value: op[1],
+                done: false
+              };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+          value: op[0] ? op[1] : undefined,
+          done: true
+        };
+      }
+    }
+    function __values(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator,
+        m = s && o[s],
+        i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+        next: function () {
+          if (o && i >= o.length) o = undefined;
+          return {
+            value: o && o[i++],
+            done: !o
+          };
+        }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o),
+        r,
+        ar = [],
+        e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = {
+          error: error
+        };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    }
+    function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    }
+    function __await(v) {
+      return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []),
+        i,
+        q = [];
+      return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () {
+        return this;
+      }, i;
+      function awaitReturn(f) {
+        return function (v) {
+          return Promise.resolve(v).then(f, reject);
+        };
+      }
+      function verb(n, f) {
+        if (g[n]) {
+          i[n] = function (v) {
+            return new Promise(function (a, b) {
+              q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+          };
+          if (f) i[n] = f(i[n]);
+        }
+      }
+      function resume(n, v) {
+        try {
+          step(g[n](v));
+        } catch (e) {
+          settle(q[0][3], e);
+        }
+      }
+      function step(r) {
+        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+      }
+      function fulfill(value) {
+        resume("next", value);
+      }
+      function reject(value) {
+        resume("throw", value);
+      }
+      function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+      }
+    }
+    function __asyncValues(o) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var m = o[Symbol.asyncIterator],
+        i;
+      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+        return this;
+      }, i);
+      function verb(n) {
+        i[n] = o[n] && function (v) {
+          return new Promise(function (resolve, reject) {
+            v = o[n](v), settle(resolve, reject, v.done, v.value);
+          });
+        };
+      }
+      function settle(resolve, reject, d, v) {
+        Promise.resolve(v).then(function (v) {
+          resolve({
+            value: v,
+            done: d
+          });
+        }, reject);
+      }
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+      if (kind === "m") throw new TypeError("Private method is not writable");
+      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+      return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+    }
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    const AirAuthMessageTypes = {
+      AUTH_SETUP_COMPLETED: "air_auth_setup_completed",
+      INITIALIZATION_REQUEST: "air_auth_initialization_request",
+      INITIALIZATION_RESPONSE: "air_auth_initialization_response",
+      LOGIN_REQUEST: "air_auth_login_request",
+      LOGIN_RESPONSE: "air_auth_login_response",
+      LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response",
+      USER_INFO_REQUEST: "air_auth_user_info_request",
+      USER_INFO_RESPONSE: "air_auth_user_info_response",
+      PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request",
+      PARTNER_USER_INFO_RESPONSE: "air_auth_partner_user_info_response",
+      REFRESH_TOKEN_REQUEST: "air_auth_refresh_token_request",
+      REFRESH_TOKEN_RESPONSE: "air_auth_refresh_token_response",
+      WALLET_TOKEN_REQUEST: "air_auth_wallet_token_request",
+      WALLET_TOKEN_RESPONSE: "air_auth_wallet_token_response",
+      INIT_WALLET_COMMUNICATION: "air_auth_init_wallet_communication",
+      IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
+      SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
+      SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
+      SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request",
+      SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
+      LOGOUT_REQUEST: "air_auth_logout_request",
+      LOGOUT_RESPONSE: "air_auth_logout_response"
+    };
+
+    const AirMessageTypes = {
+      SERVICE_STARTED: "air_service_started",
+      INITIALIZATION_REQUEST: "air_initialization_request",
+      INITIALIZATION_RESPONSE: "air_initialization_response",
+      INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
+      WALLET_INITIALIZED: "air_wallet_initialized",
+      LOGIN_REQUEST: "air_login_request",
+      CLAIM_REQUEST: "air_claim_request",
+      LOGIN_CLAIM_STATE: "air_login_claim_state",
+      CLOSE_MODAL: "air_close_modal",
+      DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
+      DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
+      GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request",
+      GRANT_PERMISSIONS_RESPONSE: "air_grant_permissions_response",
+      EXECUTE_ACTION_REQUEST: "air_execute_action_request",
+      EXECUTE_ACTION_RESPONSE: "air_execute_action_response",
+      REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request",
+      REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response",
+      WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request"
+    };
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    var fastDeepEqual;
+    var hasRequiredFastDeepEqual;
+    function requireFastDeepEqual() {
+      if (hasRequiredFastDeepEqual) return fastDeepEqual;
+      hasRequiredFastDeepEqual = 1;
+
+      // do not edit .js files directly - edit src/index.jst
+
+      fastDeepEqual = function equal(a, b) {
+        if (a === b) return true;
+        if (a && b && typeof a == 'object' && typeof b == 'object') {
+          if (a.constructor !== b.constructor) return false;
+          var length, i, keys;
+          if (Array.isArray(a)) {
+            length = a.length;
+            if (length != b.length) return false;
+            for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
+            return true;
+          }
+          if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+          if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+          if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+          keys = Object.keys(a);
+          length = keys.length;
+          if (length !== Object.keys(b).length) return false;
+          for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+          for (i = length; i-- !== 0;) {
+            var key = keys[i];
+            if (!equal(a[key], b[key])) return false;
+          }
+          return true;
+        }
+
+        // true if both NaN, false otherwise
+        return a !== a && b !== b;
+      };
+      return fastDeepEqual;
+    }
+
+    var fastDeepEqualExports = requireFastDeepEqual();
+    var equal = /*@__PURE__*/getDefaultExportFromCjs(fastDeepEqualExports);
+
+    function isFunction(value) {
+      return typeof value === 'function';
+    }
+
+    function createErrorClass(createImpl) {
+      var _super = function (instance) {
+        Error.call(instance);
+        instance.stack = new Error().stack;
+      };
+      var ctorFunc = createImpl(_super);
+      ctorFunc.prototype = Object.create(Error.prototype);
+      ctorFunc.prototype.constructor = ctorFunc;
+      return ctorFunc;
+    }
+
+    var UnsubscriptionError = createErrorClass(function (_super) {
+      return function UnsubscriptionErrorImpl(errors) {
+        _super(this);
+        this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
+          return i + 1 + ") " + err.toString();
+        }).join('\n  ') : '';
+        this.name = 'UnsubscriptionError';
+        this.errors = errors;
+      };
+    });
+
+    function arrRemove(arr, item) {
+      if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+      }
+    }
+
+    var Subscription = function () {
+      function Subscription(initialTeardown) {
+        this.initialTeardown = initialTeardown;
+        this.closed = false;
+        this._parentage = null;
+        this._finalizers = null;
+      }
+      Subscription.prototype.unsubscribe = function () {
+        var e_1, _a, e_2, _b;
+        var errors;
+        if (!this.closed) {
+          this.closed = true;
+          var _parentage = this._parentage;
+          if (_parentage) {
+            this._parentage = null;
+            if (Array.isArray(_parentage)) {
+              try {
+                for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                  var parent_1 = _parentage_1_1.value;
+                  parent_1.remove(this);
+                }
+              } catch (e_1_1) {
+                e_1 = {
+                  error: e_1_1
+                };
+              } finally {
+                try {
+                  if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                } finally {
+                  if (e_1) throw e_1.error;
+                }
+              }
+            } else {
+              _parentage.remove(this);
+            }
+          }
+          var initialFinalizer = this.initialTeardown;
+          if (isFunction(initialFinalizer)) {
+            try {
+              initialFinalizer();
+            } catch (e) {
+              errors = e instanceof UnsubscriptionError ? e.errors : [e];
+            }
+          }
+          var _finalizers = this._finalizers;
+          if (_finalizers) {
+            this._finalizers = null;
+            try {
+              for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+                var finalizer = _finalizers_1_1.value;
+                try {
+                  execFinalizer(finalizer);
+                } catch (err) {
+                  errors = errors !== null && errors !== void 0 ? errors : [];
+                  if (err instanceof UnsubscriptionError) {
+                    errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                  } else {
+                    errors.push(err);
+                  }
+                }
+              }
+            } catch (e_2_1) {
+              e_2 = {
+                error: e_2_1
+              };
+            } finally {
+              try {
+                if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+              } finally {
+                if (e_2) throw e_2.error;
+              }
+            }
+          }
+          if (errors) {
+            throw new UnsubscriptionError(errors);
+          }
+        }
+      };
+      Subscription.prototype.add = function (teardown) {
+        var _a;
+        if (teardown && teardown !== this) {
+          if (this.closed) {
+            execFinalizer(teardown);
+          } else {
+            if (teardown instanceof Subscription) {
+              if (teardown.closed || teardown._hasParent(this)) {
+                return;
+              }
+              teardown._addParent(this);
+            }
+            (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
+          }
+        }
+      };
+      Subscription.prototype._hasParent = function (parent) {
+        var _parentage = this._parentage;
+        return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+      };
+      Subscription.prototype._addParent = function (parent) {
+        var _parentage = this._parentage;
+        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+      };
+      Subscription.prototype._removeParent = function (parent) {
+        var _parentage = this._parentage;
+        if (_parentage === parent) {
+          this._parentage = null;
+        } else if (Array.isArray(_parentage)) {
+          arrRemove(_parentage, parent);
+        }
+      };
+      Subscription.prototype.remove = function (teardown) {
+        var _finalizers = this._finalizers;
+        _finalizers && arrRemove(_finalizers, teardown);
+        if (teardown instanceof Subscription) {
+          teardown._removeParent(this);
+        }
+      };
+      Subscription.EMPTY = function () {
+        var empty = new Subscription();
+        empty.closed = true;
+        return empty;
+      }();
+      return Subscription;
+    }();
+    var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+    function isSubscription(value) {
+      return value instanceof Subscription || value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+    }
+    function execFinalizer(finalizer) {
+      if (isFunction(finalizer)) {
+        finalizer();
+      } else {
+        finalizer.unsubscribe();
+      }
+    }
+
+    var config = {
+      onUnhandledError: null,
+      onStoppedNotification: null,
+      Promise: undefined,
+      useDeprecatedSynchronousErrorHandling: false,
+      useDeprecatedNextContext: false
+    };
+
+    var timeoutProvider = {
+      setTimeout: function (handler, timeout) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+          args[_i - 2] = arguments[_i];
+        }
+        return setTimeout.apply(undefined, __spreadArray([handler, timeout], __read(args)));
+      },
+      clearTimeout: function (handle) {
+        return (clearTimeout)(handle);
+      },
+      delegate: undefined
+    };
+
+    function reportUnhandledError(err) {
+      timeoutProvider.setTimeout(function () {
+        {
+          throw err;
+        }
+      });
+    }
+
+    function noop() {}
+
+    function errorContext(cb) {
+      {
+        cb();
+      }
+    }
+
+    var Subscriber = function (_super) {
+      __extends(Subscriber, _super);
+      function Subscriber(destination) {
+        var _this = _super.call(this) || this;
+        _this.isStopped = false;
+        if (destination) {
+          _this.destination = destination;
+          if (isSubscription(destination)) {
+            destination.add(_this);
+          }
+        } else {
+          _this.destination = EMPTY_OBSERVER;
+        }
+        return _this;
+      }
+      Subscriber.create = function (next, error, complete) {
+        return new SafeSubscriber(next, error, complete);
+      };
+      Subscriber.prototype.next = function (value) {
+        if (this.isStopped) ; else {
+          this._next(value);
+        }
+      };
+      Subscriber.prototype.error = function (err) {
+        if (this.isStopped) ; else {
+          this.isStopped = true;
+          this._error(err);
+        }
+      };
+      Subscriber.prototype.complete = function () {
+        if (this.isStopped) ; else {
+          this.isStopped = true;
+          this._complete();
+        }
+      };
+      Subscriber.prototype.unsubscribe = function () {
+        if (!this.closed) {
+          this.isStopped = true;
+          _super.prototype.unsubscribe.call(this);
+          this.destination = null;
+        }
+      };
+      Subscriber.prototype._next = function (value) {
+        this.destination.next(value);
+      };
+      Subscriber.prototype._error = function (err) {
+        try {
+          this.destination.error(err);
+        } finally {
+          this.unsubscribe();
+        }
+      };
+      Subscriber.prototype._complete = function () {
+        try {
+          this.destination.complete();
+        } finally {
+          this.unsubscribe();
+        }
+      };
+      return Subscriber;
+    }(Subscription);
+    var ConsumerObserver = function () {
+      function ConsumerObserver(partialObserver) {
+        this.partialObserver = partialObserver;
+      }
+      ConsumerObserver.prototype.next = function (value) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.next) {
+          try {
+            partialObserver.next(value);
+          } catch (error) {
+            handleUnhandledError(error);
+          }
+        }
+      };
+      ConsumerObserver.prototype.error = function (err) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.error) {
+          try {
+            partialObserver.error(err);
+          } catch (error) {
+            handleUnhandledError(error);
+          }
+        } else {
+          handleUnhandledError(err);
+        }
+      };
+      ConsumerObserver.prototype.complete = function () {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.complete) {
+          try {
+            partialObserver.complete();
+          } catch (error) {
+            handleUnhandledError(error);
+          }
+        }
+      };
+      return ConsumerObserver;
+    }();
+    var SafeSubscriber = function (_super) {
+      __extends(SafeSubscriber, _super);
+      function SafeSubscriber(observerOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        var partialObserver;
+        if (isFunction(observerOrNext) || !observerOrNext) {
+          partialObserver = {
+            next: observerOrNext !== null && observerOrNext !== undefined ? observerOrNext : undefined,
+            error: error !== null && error !== undefined ? error : undefined,
+            complete: complete !== null && complete !== undefined ? complete : undefined
+          };
+        } else {
+          {
+            partialObserver = observerOrNext;
+          }
+        }
+        _this.destination = new ConsumerObserver(partialObserver);
+        return _this;
+      }
+      return SafeSubscriber;
+    }(Subscriber);
+    function handleUnhandledError(error) {
+      {
+        reportUnhandledError(error);
+      }
+    }
+    function defaultErrorHandler(err) {
+      throw err;
+    }
+    var EMPTY_OBSERVER = {
+      closed: true,
+      next: noop,
+      error: defaultErrorHandler,
+      complete: noop
+    };
+
+    var observable = function () {
+      return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+    }();
+
+    function identity(x) {
+      return x;
+    }
+
+    function pipeFromArray(fns) {
+      if (fns.length === 0) {
+        return identity;
+      }
+      if (fns.length === 1) {
+        return fns[0];
+      }
+      return function piped(input) {
+        return fns.reduce(function (prev, fn) {
+          return fn(prev);
+        }, input);
+      };
+    }
+
+    var Observable = function () {
+      function Observable(subscribe) {
+        if (subscribe) {
+          this._subscribe = subscribe;
+        }
+      }
+      Observable.prototype.lift = function (operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+      };
+      Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+        var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+        errorContext(function () {
+          var _a = _this,
+            operator = _a.operator,
+            source = _a.source;
+          subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+        });
+        return subscriber;
+      };
+      Observable.prototype._trySubscribe = function (sink) {
+        try {
+          return this._subscribe(sink);
+        } catch (err) {
+          sink.error(err);
+        }
+      };
+      Observable.prototype.forEach = function (next, promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+          var subscriber = new SafeSubscriber({
+            next: function (value) {
+              try {
+                next(value);
+              } catch (err) {
+                reject(err);
+                subscriber.unsubscribe();
+              }
+            },
+            error: reject,
+            complete: resolve
+          });
+          _this.subscribe(subscriber);
+        });
+      };
+      Observable.prototype._subscribe = function (subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
+      };
+      Observable.prototype[observable] = function () {
+        return this;
+      };
+      Observable.prototype.pipe = function () {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          operations[_i] = arguments[_i];
+        }
+        return pipeFromArray(operations)(this);
+      };
+      Observable.prototype.toPromise = function (promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+          var value;
+          _this.subscribe(function (x) {
+            return value = x;
+          }, function (err) {
+            return reject(err);
+          }, function () {
+            return resolve(value);
+          });
+        });
+      };
+      Observable.create = function (subscribe) {
+        return new Observable(subscribe);
+      };
+      return Observable;
+    }();
+    function getPromiseCtor(promiseCtor) {
+      var _a;
+      return (_a = promiseCtor !== null && promiseCtor !== undefined ? promiseCtor : config.Promise) !== null && _a !== undefined ? _a : Promise;
+    }
+    function isObserver(value) {
+      return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+    }
+    function isSubscriber(value) {
+      return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+    }
+
+    function hasLift(source) {
+      return isFunction(source === null || source === undefined ? undefined : source.lift);
+    }
+    function operate(init) {
+      return function (source) {
+        if (hasLift(source)) {
+          return source.lift(function (liftedSource) {
+            try {
+              return init(liftedSource, this);
+            } catch (err) {
+              this.error(err);
+            }
+          });
+        }
+        throw new TypeError('Unable to lift unknown Observable type');
+      };
+    }
+
+    function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+      return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+    }
+    var OperatorSubscriber = function (_super) {
+      __extends(OperatorSubscriber, _super);
+      function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+        var _this = _super.call(this, destination) || this;
+        _this.onFinalize = onFinalize;
+        _this.shouldUnsubscribe = shouldUnsubscribe;
+        _this._next = onNext ? function (value) {
+          try {
+            onNext(value);
+          } catch (err) {
+            destination.error(err);
+          }
+        } : _super.prototype._next;
+        _this._error = onError ? function (err) {
+          try {
+            onError(err);
+          } catch (err) {
+            destination.error(err);
+          } finally {
+            this.unsubscribe();
+          }
+        } : _super.prototype._error;
+        _this._complete = onComplete ? function () {
+          try {
+            onComplete();
+          } catch (err) {
+            destination.error(err);
+          } finally {
+            this.unsubscribe();
+          }
+        } : _super.prototype._complete;
+        return _this;
+      }
+      OperatorSubscriber.prototype.unsubscribe = function () {
+        var _a;
+        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+          var closed_1 = this.closed;
+          _super.prototype.unsubscribe.call(this);
+          !closed_1 && ((_a = this.onFinalize) === null || _a === undefined ? undefined : _a.call(this));
+        }
+      };
+      return OperatorSubscriber;
+    }(Subscriber);
+
+    var ObjectUnsubscribedError = createErrorClass(function (_super) {
+      return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = 'ObjectUnsubscribedError';
+        this.message = 'object unsubscribed';
+      };
+    });
+
+    var Subject = function (_super) {
+      __extends(Subject, _super);
+      function Subject() {
+        var _this = _super.call(this) || this;
+        _this.closed = false;
+        _this.currentObservers = null;
+        _this.observers = [];
+        _this.isStopped = false;
+        _this.hasError = false;
+        _this.thrownError = null;
+        return _this;
+      }
+      Subject.prototype.lift = function (operator) {
+        var subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+      };
+      Subject.prototype._throwIfClosed = function () {
+        if (this.closed) {
+          throw new ObjectUnsubscribedError();
+        }
+      };
+      Subject.prototype.next = function (value) {
+        var _this = this;
+        errorContext(function () {
+          var e_1, _a;
+          _this._throwIfClosed();
+          if (!_this.isStopped) {
+            if (!_this.currentObservers) {
+              _this.currentObservers = Array.from(_this.observers);
+            }
+            try {
+              for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var observer = _c.value;
+                observer.next(value);
+              }
+            } catch (e_1_1) {
+              e_1 = {
+                error: e_1_1
+              };
+            } finally {
+              try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          }
+        });
+      };
+      Subject.prototype.error = function (err) {
+        var _this = this;
+        errorContext(function () {
+          _this._throwIfClosed();
+          if (!_this.isStopped) {
+            _this.hasError = _this.isStopped = true;
+            _this.thrownError = err;
+            var observers = _this.observers;
+            while (observers.length) {
+              observers.shift().error(err);
+            }
+          }
+        });
+      };
+      Subject.prototype.complete = function () {
+        var _this = this;
+        errorContext(function () {
+          _this._throwIfClosed();
+          if (!_this.isStopped) {
+            _this.isStopped = true;
+            var observers = _this.observers;
+            while (observers.length) {
+              observers.shift().complete();
+            }
+          }
+        });
+      };
+      Subject.prototype.unsubscribe = function () {
+        this.isStopped = this.closed = true;
+        this.observers = this.currentObservers = null;
+      };
+      Object.defineProperty(Subject.prototype, "observed", {
+        get: function () {
+          var _a;
+          return ((_a = this.observers) === null || _a === undefined ? undefined : _a.length) > 0;
+        },
+        enumerable: false,
+        configurable: true
+      });
+      Subject.prototype._trySubscribe = function (subscriber) {
+        this._throwIfClosed();
+        return _super.prototype._trySubscribe.call(this, subscriber);
+      };
+      Subject.prototype._subscribe = function (subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+      };
+      Subject.prototype._innerSubscribe = function (subscriber) {
+        var _this = this;
+        var _a = this,
+          hasError = _a.hasError,
+          isStopped = _a.isStopped,
+          observers = _a.observers;
+        if (hasError || isStopped) {
+          return EMPTY_SUBSCRIPTION;
+        }
+        this.currentObservers = null;
+        observers.push(subscriber);
+        return new Subscription(function () {
+          _this.currentObservers = null;
+          arrRemove(observers, subscriber);
+        });
+      };
+      Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+        var _a = this,
+          hasError = _a.hasError,
+          thrownError = _a.thrownError,
+          isStopped = _a.isStopped;
+        if (hasError) {
+          subscriber.error(thrownError);
+        } else if (isStopped) {
+          subscriber.complete();
+        }
+      };
+      Subject.prototype.asObservable = function () {
+        var observable = new Observable();
+        observable.source = this;
+        return observable;
+      };
+      Subject.create = function (destination, source) {
+        return new AnonymousSubject(destination, source);
+      };
+      return Subject;
+    }(Observable);
+    var AnonymousSubject = function (_super) {
+      __extends(AnonymousSubject, _super);
+      function AnonymousSubject(destination, source) {
+        var _this = _super.call(this) || this;
+        _this.destination = destination;
+        _this.source = source;
+        return _this;
+      }
+      AnonymousSubject.prototype.next = function (value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.next) === null || _b === undefined ? undefined : _b.call(_a, value);
+      };
+      AnonymousSubject.prototype.error = function (err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.error) === null || _b === undefined ? undefined : _b.call(_a, err);
+      };
+      AnonymousSubject.prototype.complete = function () {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
+      };
+      AnonymousSubject.prototype._subscribe = function (subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber)) !== null && _b !== undefined ? _b : EMPTY_SUBSCRIPTION;
+      };
+      return AnonymousSubject;
+    }(Subject);
+
+    var EMPTY = new Observable(function (subscriber) {
+      return subscriber.complete();
+    });
+
+    function last$1(arr) {
+      return arr[arr.length - 1];
+    }
+    function popResultSelector(args) {
+      return isFunction(last$1(args)) ? args.pop() : undefined;
+    }
+
+    var isArrayLike = function (x) {
+      return x && typeof x.length === 'number' && typeof x !== 'function';
+    };
+
+    function isPromise(value) {
+      return isFunction(value === null || value === undefined ? undefined : value.then);
+    }
+
+    function isInteropObservable(input) {
+      return isFunction(input[observable]);
+    }
+
+    function isAsyncIterable(obj) {
+      return Symbol.asyncIterator && isFunction(obj === null || obj === undefined ? undefined : obj[Symbol.asyncIterator]);
+    }
+
+    function createInvalidObservableTypeError(input) {
+      return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+    }
+
+    function getSymbolIterator() {
+      if (typeof Symbol !== 'function' || !Symbol.iterator) {
+        return '@@iterator';
+      }
+      return Symbol.iterator;
+    }
+    var iterator = getSymbolIterator();
+
+    function isIterable(input) {
+      return isFunction(input === null || input === undefined ? undefined : input[iterator]);
+    }
+
+    function readableStreamLikeToAsyncGenerator(readableStream) {
+      return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+        var reader, _a, value, done;
+        return __generator(this, function (_b) {
+          switch (_b.label) {
+            case 0:
+              reader = readableStream.getReader();
+              _b.label = 1;
+            case 1:
+              _b.trys.push([1,, 9, 10]);
+              _b.label = 2;
+            case 2:
+              return [4, __await(reader.read())];
+            case 3:
+              _a = _b.sent(), value = _a.value, done = _a.done;
+              if (!done) return [3, 5];
+              return [4, __await(undefined)];
+            case 4:
+              return [2, _b.sent()];
+            case 5:
+              return [4, __await(value)];
+            case 6:
+              return [4, _b.sent()];
+            case 7:
+              _b.sent();
+              return [3, 2];
+            case 8:
+              return [3, 10];
+            case 9:
+              reader.releaseLock();
+              return [7];
+            case 10:
+              return [2];
+          }
+        });
+      });
+    }
+    function isReadableStreamLike(obj) {
+      return isFunction(obj === null || obj === undefined ? undefined : obj.getReader);
+    }
+
+    function innerFrom(input) {
+      if (input instanceof Observable) {
+        return input;
+      }
+      if (input != null) {
+        if (isInteropObservable(input)) {
+          return fromInteropObservable(input);
+        }
+        if (isArrayLike(input)) {
+          return fromArrayLike(input);
+        }
+        if (isPromise(input)) {
+          return fromPromise(input);
+        }
+        if (isAsyncIterable(input)) {
+          return fromAsyncIterable(input);
+        }
+        if (isIterable(input)) {
+          return fromIterable(input);
+        }
+        if (isReadableStreamLike(input)) {
+          return fromReadableStreamLike(input);
+        }
+      }
+      throw createInvalidObservableTypeError(input);
+    }
+    function fromInteropObservable(obj) {
+      return new Observable(function (subscriber) {
+        var obs = obj[observable]();
+        if (isFunction(obs.subscribe)) {
+          return obs.subscribe(subscriber);
+        }
+        throw new TypeError('Provided object does not correctly implement Symbol.observable');
+      });
+    }
+    function fromArrayLike(array) {
+      return new Observable(function (subscriber) {
+        for (var i = 0; i < array.length && !subscriber.closed; i++) {
+          subscriber.next(array[i]);
+        }
+        subscriber.complete();
+      });
+    }
+    function fromPromise(promise) {
+      return new Observable(function (subscriber) {
+        promise.then(function (value) {
+          if (!subscriber.closed) {
+            subscriber.next(value);
+            subscriber.complete();
+          }
+        }, function (err) {
+          return subscriber.error(err);
+        }).then(null, reportUnhandledError);
+      });
+    }
+    function fromIterable(iterable) {
+      return new Observable(function (subscriber) {
+        var e_1, _a;
+        try {
+          for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+            var value = iterable_1_1.value;
+            subscriber.next(value);
+            if (subscriber.closed) {
+              return;
+            }
+          }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
+          try {
+            if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+        subscriber.complete();
+      });
+    }
+    function fromAsyncIterable(asyncIterable) {
+      return new Observable(function (subscriber) {
+        process(asyncIterable, subscriber).catch(function (err) {
+          return subscriber.error(err);
+        });
+      });
+    }
+    function fromReadableStreamLike(readableStream) {
+      return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+    }
+    function process(asyncIterable, subscriber) {
+      var asyncIterable_1, asyncIterable_1_1;
+      var e_2, _a;
+      return __awaiter(this, undefined, undefined, function () {
+        var value, e_2_1;
+        return __generator(this, function (_b) {
+          switch (_b.label) {
+            case 0:
+              _b.trys.push([0, 5, 6, 11]);
+              asyncIterable_1 = __asyncValues(asyncIterable);
+              _b.label = 1;
+            case 1:
+              return [4, asyncIterable_1.next()];
+            case 2:
+              if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+              value = asyncIterable_1_1.value;
+              subscriber.next(value);
+              if (subscriber.closed) {
+                return [2];
+              }
+              _b.label = 3;
+            case 3:
+              return [3, 1];
+            case 4:
+              return [3, 11];
+            case 5:
+              e_2_1 = _b.sent();
+              e_2 = {
+                error: e_2_1
+              };
+              return [3, 11];
+            case 6:
+              _b.trys.push([6,, 9, 10]);
+              if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+              return [4, _a.call(asyncIterable_1)];
+            case 7:
+              _b.sent();
+              _b.label = 8;
+            case 8:
+              return [3, 10];
+            case 9:
+              if (e_2) throw e_2.error;
+              return [7];
+            case 10:
+              return [7];
+            case 11:
+              subscriber.complete();
+              return [2];
+          }
+        });
+      });
+    }
+
+    var EmptyError = createErrorClass(function (_super) {
+      return function EmptyErrorImpl() {
+        _super(this);
+        this.name = 'EmptyError';
+        this.message = 'no elements in sequence';
+      };
+    });
+
+    function lastValueFrom(source, config) {
+      return new Promise(function (resolve, reject) {
+        var _hasValue = false;
+        var _value;
+        source.subscribe({
+          next: function (value) {
+            _value = value;
+            _hasValue = true;
+          },
+          error: reject,
+          complete: function () {
+            if (_hasValue) {
+              resolve(_value);
+            } else {
+              reject(new EmptyError());
+            }
+          }
+        });
+      });
+    }
+
+    function firstValueFrom(source, config) {
+      return new Promise(function (resolve, reject) {
+        var subscriber = new SafeSubscriber({
+          next: function (value) {
+            resolve(value);
+            subscriber.unsubscribe();
+          },
+          error: reject,
+          complete: function () {
+            {
+              reject(new EmptyError());
+            }
+          }
+        });
+        source.subscribe(subscriber);
+      });
+    }
+
+    function map(project, thisArg) {
+      return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          subscriber.next(project.call(thisArg, value, index++));
+        }));
+      });
+    }
+
+    var isArray$1 = Array.isArray;
+    function callOrApply(fn, args) {
+      return isArray$1(args) ? fn.apply(undefined, __spreadArray([], __read(args))) : fn(args);
+    }
+    function mapOneOrManyArgs(fn) {
+      return map(function (args) {
+        return callOrApply(fn, args);
+      });
+    }
+
+    var isArray = Array.isArray;
+    var getPrototypeOf = Object.getPrototypeOf,
+      objectProto = Object.prototype,
+      getKeys = Object.keys;
+    function argsArgArrayOrObject(args) {
+      if (args.length === 1) {
+        var first_1 = args[0];
+        if (isArray(first_1)) {
+          return {
+            args: first_1,
+            keys: null
+          };
+        }
+        if (isPOJO(first_1)) {
+          var keys = getKeys(first_1);
+          return {
+            args: keys.map(function (key) {
+              return first_1[key];
+            }),
+            keys: keys
+          };
+        }
+      }
+      return {
+        args: args,
+        keys: null
+      };
+    }
+    function isPOJO(obj) {
+      return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto;
+    }
+
+    function createObject(keys, values) {
+      return keys.reduce(function (result, key, i) {
+        return result[key] = values[i], result;
+      }, {});
+    }
+
+    function forkJoin() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      var resultSelector = popResultSelector(args);
+      var _a = argsArgArrayOrObject(args),
+        sources = _a.args,
+        keys = _a.keys;
+      var result = new Observable(function (subscriber) {
+        var length = sources.length;
+        if (!length) {
+          subscriber.complete();
+          return;
+        }
+        var values = new Array(length);
+        var remainingCompletions = length;
+        var remainingEmissions = length;
+        var _loop_1 = function (sourceIndex) {
+          var hasValue = false;
+          innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, function (value) {
+            if (!hasValue) {
+              hasValue = true;
+              remainingEmissions--;
+            }
+            values[sourceIndex] = value;
+          }, function () {
+            return remainingCompletions--;
+          }, undefined, function () {
+            if (!remainingCompletions || !hasValue) {
+              if (!remainingEmissions) {
+                subscriber.next(keys ? createObject(keys, values) : values);
+              }
+              subscriber.complete();
+            }
+          }));
+        };
+        for (var sourceIndex = 0; sourceIndex < length; sourceIndex++) {
+          _loop_1(sourceIndex);
+        }
+      });
+      return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+    }
+
+    function filter(predicate, thisArg) {
+      return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          return predicate.call(thisArg, value, index++) && subscriber.next(value);
+        }));
+      });
+    }
+
+    function defaultIfEmpty(defaultValue) {
+      return operate(function (source, subscriber) {
+        var hasValue = false;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          hasValue = true;
+          subscriber.next(value);
+        }, function () {
+          if (!hasValue) {
+            subscriber.next(defaultValue);
+          }
+          subscriber.complete();
+        }));
+      });
+    }
+
+    function take(count) {
+      return count <= 0 ? function () {
+        return EMPTY;
+      } : operate(function (source, subscriber) {
+        var seen = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          if (++seen <= count) {
+            subscriber.next(value);
+            if (count <= seen) {
+              subscriber.complete();
+            }
+          }
+        }));
+      });
+    }
+
+    function distinctUntilChanged(comparator, keySelector) {
+      if (keySelector === undefined) {
+        keySelector = identity;
+      }
+      comparator = comparator !== null && comparator !== undefined ? comparator : defaultCompare;
+      return operate(function (source, subscriber) {
+        var previousKey;
+        var first = true;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          var currentKey = keySelector(value);
+          if (first || !comparator(previousKey, currentKey)) {
+            first = false;
+            previousKey = currentKey;
+            subscriber.next(value);
+          }
+        }));
+      });
+    }
+    function defaultCompare(a, b) {
+      return a === b;
+    }
+
+    function throwIfEmpty(errorFactory) {
+      if (errorFactory === undefined) {
+        errorFactory = defaultErrorFactory;
+      }
+      return operate(function (source, subscriber) {
+        var hasValue = false;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          hasValue = true;
+          subscriber.next(value);
+        }, function () {
+          return hasValue ? subscriber.complete() : subscriber.error(errorFactory());
+        }));
+      });
+    }
+    function defaultErrorFactory() {
+      return new EmptyError();
+    }
+
+    function first(predicate, defaultValue) {
+      var hasDefaultValue = arguments.length >= 2;
+      return function (source) {
+        return source.pipe(identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () {
+          return new EmptyError();
+        }));
+      };
+    }
+
+    function takeLast(count) {
+      return count <= 0 ? function () {
+        return EMPTY;
+      } : operate(function (source, subscriber) {
+        var buffer = [];
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          buffer.push(value);
+          count < buffer.length && buffer.shift();
+        }, function () {
+          var e_1, _a;
+          try {
+            for (var buffer_1 = __values(buffer), buffer_1_1 = buffer_1.next(); !buffer_1_1.done; buffer_1_1 = buffer_1.next()) {
+              var value = buffer_1_1.value;
+              subscriber.next(value);
+            }
+          } catch (e_1_1) {
+            e_1 = {
+              error: e_1_1
+            };
+          } finally {
+            try {
+              if (buffer_1_1 && !buffer_1_1.done && (_a = buffer_1.return)) _a.call(buffer_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+          subscriber.complete();
+        }, undefined, function () {
+          buffer = null;
+        }));
+      });
+    }
+
+    function last(predicate, defaultValue) {
+      var hasDefaultValue = arguments.length >= 2;
+      return function (source) {
+        return source.pipe(identity, takeLast(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () {
+          return new EmptyError();
+        }));
+      };
+    }
+
+    function takeWhile(predicate, inclusive) {
+      return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          var result = predicate(value, index++);
+          (result || inclusive) && subscriber.next(value);
+          !result && subscriber.complete();
+        }));
+      });
+    }
+
+    function tap(observerOrNext, error, complete) {
+      var tapObserver = isFunction(observerOrNext) || error || complete ? {
+        next: observerOrNext,
+        error: error,
+        complete: complete
+      } : observerOrNext;
+      return tapObserver ? operate(function (source, subscriber) {
+        var _a;
+        (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+        var isUnsub = true;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          var _a;
+          (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+          subscriber.next(value);
+        }, function () {
+          var _a;
+          isUnsub = false;
+          (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+          subscriber.complete();
+        }, function (err) {
+          var _a;
+          isUnsub = false;
+          (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+          subscriber.error(err);
+        }, function () {
+          var _a, _b;
+          if (isUnsub) {
+            (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+          }
+          (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+        }));
+      }) : identity;
+    }
+
+    class BaseError extends Error {
+      constructor(name, message, options = {}) {
+        const {
+          cause,
+          context
+        } = options;
+        super(message || name);
+        this.name = name;
+        this.stack = cause?.stack;
+        this.cause = cause;
+        this.context = context;
+      }
+      toJSON() {
+        return {
+          name: this.name,
+          message: this.message,
+          context: this.context,
+          cause: this.cause
+        };
+      }
+    }
+
+    class AirServiceError extends BaseError {
+        static from(error) {
+            if (error instanceof AirServiceError) {
+                return error;
+            }
+            else if (error instanceof Object && "message" in error) {
+                if (error.message === "User cancelled login") {
+                    return new AirServiceError("USER_CANCELLED", error.message);
+                }
+                return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
+            }
+            return new AirServiceError("UNKNOWN_ERROR");
+        }
+    }
+    class RealmEmbedError extends AirServiceError {
+    }
+
+    var loglevel$2 = {exports: {}};
+
+    /*
+    * loglevel - https://github.com/pimterry/loglevel
+    *
+    * Copyright (c) 2013 Tim Perry
+    * Licensed under the MIT license.
+    */
+    var loglevel$1 = loglevel$2.exports;
+    var hasRequiredLoglevel;
+    function requireLoglevel() {
+      if (hasRequiredLoglevel) return loglevel$2.exports;
+      hasRequiredLoglevel = 1;
+      (function (module) {
+        (function (root, definition) {
+
+          if (module.exports) {
+            module.exports = definition();
+          } else {
+            root.log = definition();
+          }
+        })(loglevel$1, function () {
+
+          // Slightly dubious tricks to cut down minimized file size
+          var noop = function () {};
+          var undefinedType = "undefined";
+          var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+          var logMethods = ["trace", "debug", "info", "warn", "error"];
+          var _loggersByName = {};
+          var defaultLogger = null;
+
+          // Cross-browser bind equivalent that works at least back to IE6
+          function bindMethod(obj, methodName) {
+            var method = obj[methodName];
+            if (typeof method.bind === 'function') {
+              return method.bind(obj);
+            } else {
+              try {
+                return Function.prototype.bind.call(method, obj);
+              } catch (e) {
+                // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+                return function () {
+                  return Function.prototype.apply.apply(method, [obj, arguments]);
+                };
+              }
+            }
+          }
+
+          // Trace() doesn't print the message in IE, so for that case we need to wrap it
+          function traceForIE() {
+            if (console.log) {
+              if (console.log.apply) {
+                console.log.apply(console, arguments);
+              } else {
+                // In old IE, native console methods themselves don't have apply().
+                Function.prototype.apply.apply(console.log, [console, arguments]);
+              }
+            }
+            if (console.trace) console.trace();
+          }
+
+          // Build the best logging method possible for this env
+          // Wherever possible we want to bind, not wrap, to preserve stack traces
+          function realMethod(methodName) {
+            if (methodName === 'debug') {
+              methodName = 'log';
+            }
+            if (typeof console === undefinedType) {
+              return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
+            } else if (methodName === 'trace' && isIE) {
+              return traceForIE;
+            } else if (console[methodName] !== undefined) {
+              return bindMethod(console, methodName);
+            } else if (console.log !== undefined) {
+              return bindMethod(console, 'log');
+            } else {
+              return noop;
+            }
+          }
+
+          // These private functions always need `this` to be set properly
+
+          function replaceLoggingMethods() {
+            /*jshint validthis:true */
+            var level = this.getLevel();
+
+            // Replace the actual methods.
+            for (var i = 0; i < logMethods.length; i++) {
+              var methodName = logMethods[i];
+              this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
+            }
+
+            // Define log.log as an alias for log.debug
+            this.log = this.debug;
+
+            // Return any important warnings.
+            if (typeof console === undefinedType && level < this.levels.SILENT) {
+              return "No console available for logging";
+            }
+          }
+
+          // In old IE versions, the console isn't present until you first open it.
+          // We build realMethod() replacements here that regenerate logging methods
+          function enableLoggingWhenConsoleArrives(methodName) {
+            return function () {
+              if (typeof console !== undefinedType) {
+                replaceLoggingMethods.call(this);
+                this[methodName].apply(this, arguments);
+              }
+            };
+          }
+
+          // By default, we use closely bound real methods wherever possible, and
+          // otherwise we wait for a console to appear, and then try again.
+          function defaultMethodFactory(methodName, _level, _loggerName) {
+            /*jshint validthis:true */
+            return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+          }
+          function Logger(name, factory) {
+            // Private instance variables.
+            var self = this;
+            /**
+             * The level inherited from a parent logger (or a global default). We
+             * cache this here rather than delegating to the parent so that it stays
+             * in sync with the actual logging methods that we have installed (the
+             * parent could change levels but we might not have rebuilt the loggers
+             * in this child yet).
+             * @type {number}
+             */
+            var inheritedLevel;
+            /**
+             * The default level for this logger, if any. If set, this overrides
+             * `inheritedLevel`.
+             * @type {number|null}
+             */
+            var defaultLevel;
+            /**
+             * A user-specific level for this logger. If set, this overrides
+             * `defaultLevel`.
+             * @type {number|null}
+             */
+            var userLevel;
+            var storageKey = "loglevel";
+            if (typeof name === "string") {
+              storageKey += ":" + name;
+            } else if (typeof name === "symbol") {
+              storageKey = undefined;
+            }
+            function persistLevelIfPossible(levelNum) {
+              var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+              if (typeof window === undefinedType || !storageKey) return;
+
+              // Use localStorage if available
+              try {
+                window.localStorage[storageKey] = levelName;
+                return;
+              } catch (ignore) {}
+
+              // Use session cookie as fallback
+              try {
+                window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+              } catch (ignore) {}
+            }
+            function getPersistedLevel() {
+              var storedLevel;
+              if (typeof window === undefinedType || !storageKey) return;
+              try {
+                storedLevel = window.localStorage[storageKey];
+              } catch (ignore) {}
+
+              // Fallback to cookies if local storage gives us nothing
+              if (typeof storedLevel === undefinedType) {
+                try {
+                  var cookie = window.document.cookie;
+                  var cookieName = encodeURIComponent(storageKey);
+                  var location = cookie.indexOf(cookieName + "=");
+                  if (location !== -1) {
+                    storedLevel = /^([^;]+)/.exec(cookie.slice(location + cookieName.length + 1))[1];
+                  }
+                } catch (ignore) {}
+              }
+
+              // If the stored level is not valid, treat it as if nothing was stored.
+              if (self.levels[storedLevel] === undefined) {
+                storedLevel = undefined;
+              }
+              return storedLevel;
+            }
+            function clearPersistedLevel() {
+              if (typeof window === undefinedType || !storageKey) return;
+
+              // Use localStorage if available
+              try {
+                window.localStorage.removeItem(storageKey);
+              } catch (ignore) {}
+
+              // Use session cookie as fallback
+              try {
+                window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+              } catch (ignore) {}
+            }
+            function normalizeLevel(input) {
+              var level = input;
+              if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+                level = self.levels[level.toUpperCase()];
+              }
+              if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+                return level;
+              } else {
+                throw new TypeError("log.setLevel() called with invalid level: " + input);
+              }
+            }
+
+            /*
+             *
+             * Public logger API - see https://github.com/pimterry/loglevel for details
+             *
+             */
+
+            self.name = name;
+            self.levels = {
+              "TRACE": 0,
+              "DEBUG": 1,
+              "INFO": 2,
+              "WARN": 3,
+              "ERROR": 4,
+              "SILENT": 5
+            };
+            self.methodFactory = factory || defaultMethodFactory;
+            self.getLevel = function () {
+              if (userLevel != null) {
+                return userLevel;
+              } else if (defaultLevel != null) {
+                return defaultLevel;
+              } else {
+                return inheritedLevel;
+              }
+            };
+            self.setLevel = function (level, persist) {
+              userLevel = normalizeLevel(level);
+              if (persist !== false) {
+                // defaults to true
+                persistLevelIfPossible(userLevel);
+              }
+
+              // NOTE: in v2, this should call rebuild(), which updates children.
+              return replaceLoggingMethods.call(self);
+            };
+            self.setDefaultLevel = function (level) {
+              defaultLevel = normalizeLevel(level);
+              if (!getPersistedLevel()) {
+                self.setLevel(level, false);
+              }
+            };
+            self.resetLevel = function () {
+              userLevel = null;
+              clearPersistedLevel();
+              replaceLoggingMethods.call(self);
+            };
+            self.enableAll = function (persist) {
+              self.setLevel(self.levels.TRACE, persist);
+            };
+            self.disableAll = function (persist) {
+              self.setLevel(self.levels.SILENT, persist);
+            };
+            self.rebuild = function () {
+              if (defaultLogger !== self) {
+                inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+              }
+              replaceLoggingMethods.call(self);
+              if (defaultLogger === self) {
+                for (var childName in _loggersByName) {
+                  _loggersByName[childName].rebuild();
+                }
+              }
+            };
+
+            // Initialize all the internal levels.
+            inheritedLevel = normalizeLevel(defaultLogger ? defaultLogger.getLevel() : "WARN");
+            var initialLevel = getPersistedLevel();
+            if (initialLevel != null) {
+              userLevel = normalizeLevel(initialLevel);
+            }
+            replaceLoggingMethods.call(self);
+          }
+
+          /*
+           *
+           * Top-level API
+           *
+           */
+
+          defaultLogger = new Logger();
+          defaultLogger.getLogger = function getLogger(name) {
+            if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
+              throw new TypeError("You must supply a name when creating a logger.");
+            }
+            var logger = _loggersByName[name];
+            if (!logger) {
+              logger = _loggersByName[name] = new Logger(name, defaultLogger.methodFactory);
+            }
+            return logger;
+          };
+
+          // Grab the current global log variable in case of overwrite
+          var _log = typeof window !== undefinedType ? window.log : undefined;
+          defaultLogger.noConflict = function () {
+            if (typeof window !== undefinedType && window.log === defaultLogger) {
+              window.log = _log;
+            }
+            return defaultLogger;
+          };
+          defaultLogger.getLoggers = function getLoggers() {
+            return _loggersByName;
+          };
+
+          // ES6 default export, for compatibility
+          defaultLogger['default'] = defaultLogger;
+          return defaultLogger;
+        });
+      })(loglevel$2);
+      return loglevel$2.exports;
+    }
+
+    var loglevelExports = requireLoglevel();
+    var loglevel = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+
+    var log = loglevel.getLogger("airkit");
+
+    var AirWalletProviderMessageTypes;
+    (function (AirWalletProviderMessageTypes) {
+      AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
+      AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
+    })(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
+
+    const ACCOUNT_MESSAGES = [
+        AirMessageTypes.INITIALIZATION_RESPONSE,
+        AirMessageTypes.WALLET_INITIALIZED,
+        AirMessageTypes.LOGIN_CLAIM_STATE,
+        AirMessageTypes.CLOSE_MODAL,
+        AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE,
+        AirMessageTypes.EXECUTE_ACTION_RESPONSE,
+        AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE,
+        AirMessageTypes.GRANT_PERMISSIONS_RESPONSE,
+        AirMessageTypes.WALLET_INITIALIZED,
+        AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST
+    ];
+    const AUTH_MESSAGES = [
+        AirAuthMessageTypes.LOGIN_RESPONSE,
+        AirAuthMessageTypes.USER_INFO_RESPONSE,
+        AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+        AirAuthMessageTypes.REFRESH_TOKEN_RESPONSE,
+        AirAuthMessageTypes.INITIALIZATION_RESPONSE,
+        AirAuthMessageTypes.LOGOUT_RESPONSE,
+        AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
+        AirAuthMessageTypes.SETUP_WALLET_REQUEST,
+    ];
+    class AirMessageService {
+        constructor() {
+            this.closeAuthMessageListeners = null;
+            this.closeRealmMessageListeners = null;
+            this.closeWalletMessageListeners = null;
+        }
+        static get instance() {
+            if (!AirMessageService._instance) {
+                AirMessageService._instance = new AirMessageService();
+            }
+            return AirMessageService._instance;
+        }
+        get messages$() {
+            return this.airMessages$.asObservable();
+        }
+        get loginState$() {
+            return this._loginState$;
+        }
+        get authMessage$() {
+            return this._authMessage$.asObservable();
+        }
+        get providerMessage$() {
+            return this._providerMessage$.asObservable();
+        }
+        async openAuthObservables({ authIframeOrigin }) {
+            this.closeAuthObservables();
+            this.setupAuthObservables();
+            const handleAuthMessage = async (ev) => {
+                if (ev.origin !== authIframeOrigin || !ev.data || !(ev.data instanceof Object))
+                    return;
+                log.debug("Embed auth message received from auth", ev.data);
+                if (AUTH_MESSAGES.includes(ev.data.type)) {
+                    this._authMessage$.next(ev.data);
+                }
+            };
+            window.addEventListener("message", handleAuthMessage);
+            this.closeAuthMessageListeners = () => {
+                window.removeEventListener("message", handleAuthMessage);
+            };
+        }
+        async openWalletObservables({ walletIframeOrigin }) {
+            this.closeAirObservables();
+            this.setupAirObservables();
+            const handleMessage = async (ev) => {
+                if (ev.origin !== walletIframeOrigin || !ev.data || !(ev.data instanceof Object))
+                    return;
+                // filter out torus and communication provider messages
+                if ("target" in ev.data &&
+                    (ev.data.target === "embed_torus" || ev.data.target === "embed_communication"))
+                    return;
+                log.debug("Embed message received from wallet", ev.data);
+                if (ACCOUNT_MESSAGES.includes(ev.data.type)) {
+                    this.airMessages$.next(ev.data);
+                }
+            };
+            window.addEventListener("message", handleMessage);
+            this.closeRealmMessageListeners = () => {
+                window.removeEventListener("message", handleMessage);
+            };
+            this.closeWalletObservables();
+            this.setupWalletObservables();
+            const handleWalletMessage = async (ev) => {
+                if (ev.origin !== walletIframeOrigin || !ev.data || !(ev.data instanceof Object))
+                    return;
+                log.debug("Embed wallet message received from wallet", ev.data);
+                if (ev.data.type === AirWalletProviderMessageTypes.RESPONSE)
+                    this._providerMessage$.next(ev.data);
+            };
+            window.addEventListener("message", handleWalletMessage);
+            this.closeWalletMessageListeners = () => {
+                window.removeEventListener("message", handleWalletMessage);
+            };
+        }
+        setupIframeCommunication(authIframe, walletIframe) {
+            const channel = new MessageChannel();
+            const authOrigin = new URL(authIframe.src).origin;
+            authIframe.contentWindow.postMessage({
+                type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION,
+            }, authOrigin, [channel.port1]);
+            const walletOrigin = new URL(walletIframe.src).origin;
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.INIT_AUTH_COMMUNICATION,
+            }, walletOrigin, [channel.port2]);
+        }
+        sendLoginRequest(walletIframe, payload) {
+            const response = lastValueFrom(this.loginState$.pipe(takeWhile((msg) => (!payload.skipClaimFlow || msg.payload.state !== "connected") &&
+                msg.payload.state !== "logged_in" &&
+                msg.payload.state !== "claim_flow_cancelled", true), tap((msg) => {
+                switch (msg.payload.state) {
+                    case "claim_flow_cancelled":
+                        throw new RealmEmbedError(msg.payload.errorName, msg.payload.errorMessage);
+                }
+            })));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.LOGIN_REQUEST,
+                payload,
+            }, origin);
+            return response;
+        }
+        sendClaimRequest(walletIframe, options) {
+            const response = lastValueFrom(forkJoin([
+                this.loginState$.pipe(takeWhile((msg) => !["logged_in", "claim_flow_cancelled"].includes(msg.payload.state), true), tap((msg) => {
+                    if (msg.payload.state === "claim_flow_cancelled") {
+                        throw new RealmEmbedError(msg.payload.errorName, msg.payload.errorMessage);
+                    }
+                }), last()),
+                this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.CLOSE_MODAL), first()),
+            ]));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.CLAIM_REQUEST,
+                payload: {
+                    token: options?.token,
+                    claimInBackground: options?.background,
+                },
+            }, origin);
+            return response;
+        }
+        async sendGrantPermissionRequest(walletIframe, policies) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST,
+                payload: {
+                    policies,
+                },
+            }, origin);
+            const result = await response;
+            if (result.payload.success === false) {
+                throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return result.payload.sessionData;
+        }
+        async sendExecuteActionRequest(walletIframe, params) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.EXECUTE_ACTION_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.EXECUTE_ACTION_REQUEST,
+                payload: {
+                    sessionData: params.sessionData,
+                    call: {
+                        to: params.call.to,
+                        value: params.call.value,
+                        data: params.call.data,
+                    },
+                    sessionOwnerPrivateKey: params.sessionOwnerPrivateKey,
+                },
+            }, origin);
+            const result = await response;
+            if (result.payload.success === false) {
+                throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return result.payload.txHash;
+        }
+        async sendRevokePermissionsRequest(walletIframe, permissionId) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.REVOKE_PERMISSIONS_REQUEST,
+                payload: {
+                    permissionId,
+                },
+            }, origin);
+            const result = await response;
+            if (result.payload.success === false) {
+                throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return result.payload.txHash;
+        }
+        sendDeploySmartAccountRequest(walletIframe) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.DEPLOY_SMART_ACCOUNT_REQUEST,
+            }, origin);
+            return response;
+        }
+        async sendUserInfoRequest(authIframe) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.USER_INFO_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.USER_INFO_REQUEST }, origin);
+            return response;
+        }
+        async sendPartnerUserInfoRequest(authIframe) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.PARTNER_USER_INFO_REQUEST }, origin);
+            return response;
+        }
+        async sendAuthLoginRequest(authIframe, payload) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.LOGIN_REQUEST, payload }, origin);
+            return response;
+        }
+        async logoutAuth(authIframe) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.LOGOUT_REQUEST }, origin);
+            return response;
+        }
+        async sendAuthInitializationRequest(authIframe, payload) {
+            const response = firstValueFrom(this._authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.INITIALIZATION_REQUEST, payload }, origin);
+            return response;
+        }
+        async sendWalletInitializationRequest(walletIframe, payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.INITIALIZATION_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, origin);
+            return response;
+        }
+        async sendGrantPermissionsRequest(walletIframe, payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST, payload }, origin);
+            return response;
+        }
+        onWalletInitialized() {
+            return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.WALLET_INITIALIZED)));
+        }
+        async sendWalletProviderRequest(walletIframe, payload) {
+            const response = firstValueFrom(this.providerMessage$.pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.RESPONSE &&
+                msg.payload.requestId === payload.requestId)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirWalletProviderMessageTypes.REQUEST,
+                payload,
+            }, origin);
+            return response;
+        }
+        closeAuthObservables() {
+            if (this._authMessage$ && !this._authMessage$.closed)
+                this._authMessage$.complete();
+            if (this.closeAuthMessageListeners)
+                this.closeAuthMessageListeners();
+        }
+        closeAirObservables() {
+            if (this.airMessages$ && !this.airMessages$.closed)
+                this.airMessages$.complete();
+            if (this.closeRealmMessageListeners)
+                this.closeRealmMessageListeners();
+        }
+        closeWalletObservables() {
+            if (this._providerMessage$ && !this._providerMessage$.closed)
+                this._providerMessage$.complete();
+            if (this.closeWalletMessageListeners)
+                this.closeWalletMessageListeners();
+        }
+        setupAuthObservables() {
+            this._authMessage$ = new Subject();
+        }
+        setupAirObservables() {
+            this.airMessages$ = new Subject();
+            this._loginState$ = this.airMessages$.pipe(filter((msg) => msg.type === AirMessageTypes.LOGIN_CLAIM_STATE), distinctUntilChanged(equal));
+        }
+        setupWalletObservables() {
+            this._providerMessage$ = new Subject();
+        }
+    }
+    var AirMessageService$1 = AirMessageService.instance;
+
+    class ProviderRpcError extends Error {
+      constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+      }
+    }
+    new ProviderRpcError("Invalid JSON", -32700);
+    const ProviderRpcInvalidRequestError = new ProviderRpcError("Invalid request", -32600);
+    const ProviderRpcMethodNotFoundError = new ProviderRpcError("Method not found", -32601);
+    const ProviderRpcInvalidParamsError = new ProviderRpcError("Invalid params", -32602);
+    new ProviderRpcError("Internal error", -32603);
+    new ProviderRpcError("User rejected request", 4001);
+    new ProviderRpcError("Unauthorized", 4100);
+    new ProviderRpcError("Unsupported method", 4200);
+    new ProviderRpcError("Disconnected", 4900);
+    new ProviderRpcError("Chain Disconnected", 4901);
+    function ensureProviderRpcError(value) {
+      if (value instanceof ProviderRpcError) return value;
+      let stringified = "[Unable to stringify the thrown value]";
+      try {
+        stringified = JSON.stringify(value);
+      } catch {
+        // ignoring failed stringify
+      }
+      return new ProviderRpcError(`This value was not thrown as type ProviderRpcError: ${stringified}`, -32603);
+    }
+
+    const BUILD_ENV = {
+        PRODUCTION: "production",
+        STAGING: "staging",
+        DEVELOPMENT: "development",
+    };
+
+    const AIR_URLS = {
+        [BUILD_ENV.DEVELOPMENT]: {
+            authUrl: "http://localhost:8100",
+            walletUrl: "http://localhost:8200",
+            legacyWalletUrl: "https://localhost:4050",
+            logLevel: "debug",
+        },
+        [BUILD_ENV.STAGING]: {
+            authUrl: "https://auth.staging.air3.com",
+            walletUrl: "https://account.staging.air3.com",
+            legacyWalletUrl: "https://account.staging.realmnetwork.io",
+            logLevel: "info",
+        },
+        [BUILD_ENV.PRODUCTION]: {
+            authUrl: "https://auth.air3.com",
+            walletUrl: "https://account.air3.com",
+            legacyWalletUrl: "https://account.realmnetwork.io",
+            logLevel: "error",
+        },
+    };
+    const isElement = (element) => element instanceof Element || element instanceof Document;
+    const randomId = () => Math.random().toString(36).slice(2);
+
+    var _AirWalletProvider_walletIframe;
+    class AirWalletProvider {
+        constructor(walletIframe) {
+            _AirWalletProvider_walletIframe.set(this, undefined);
+            __classPrivateFieldSet(this, _AirWalletProvider_walletIframe, walletIframe, "f");
+        }
+        async request(request) {
+            // Check if the request is valid
+            if (!request || typeof request !== "object" || Array.isArray(request)) {
+                throw ProviderRpcInvalidRequestError;
+            }
+            const { method, params } = request;
+            // Check if the method is valid
+            if (typeof method !== "string" || method.length === 0) {
+                throw ProviderRpcMethodNotFoundError;
+            }
+            // Check if the params are valid
+            if (params !== undefined &&
+                !Array.isArray(params) &&
+                (typeof params !== "object" || params === null)) {
+                throw ProviderRpcInvalidParamsError;
+            }
+            const requestId = randomId();
+            const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_walletIframe, "f"), {
+                requestId,
+                ...request,
+            });
+            if (!response.success) {
+                const error = ensureProviderRpcError(response.payload);
+                throw error;
+            }
+            return response.payload.response;
+        }
+        on(eventName, listener) {
+            console.log("on", eventName, listener);
+        }
+        removeListener(eventName, listener) {
+            console.log("removeListener", eventName, listener);
+        }
+    }
+    _AirWalletProvider_walletIframe = new WeakMap();
+
+    class IframeController {
+        constructor(iframeUrl, iframeId, state) {
+            this._iframeElement = null;
+            this.state = {
+                ...IframeController.defaultState,
+                ...state,
+            };
+            this.iframeUrl = iframeUrl;
+            this.iframeId = iframeId;
+        }
+        get iframeElement() {
+            return this._iframeElement;
+        }
+        createIframe() {
+            if (this._iframeElement)
+                return this._iframeElement;
+            const iframe = document.createElement("iframe");
+            iframe.id = this.iframeId;
+            iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
+            iframe.src = this.iframeUrl;
+            iframe.style.position = "fixed";
+            iframe.style.zIndex = "999999";
+            iframe.style.border = "none";
+            iframe.style.margin = "0";
+            iframe.style.padding = "0";
+            iframe.style.display = "none";
+            document.body.appendChild(iframe);
+            this._iframeElement = iframe;
+            return iframe;
+        }
+        setIframeVisibility(isVisible) {
+            this.state.isVisible = isVisible;
+        }
+        updateIframeState() {
+            if (!this.iframeElement)
+                return;
+            const style = {};
+            style.display = this.state.isVisible ? "block" : "none";
+            style.width = "100%";
+            style.height = "100%";
+            style.top = "0px";
+            style.right = "0px";
+            style.left = "0px";
+            style.bottom = "0px";
+            Object.assign(this.iframeElement.style, style);
+        }
+        destroy() {
+            if (this.iframeElement) {
+                this.iframeElement.remove();
+                this._iframeElement = null;
+            }
+        }
+        postMessage(message) {
+            if (!this.iframeElement)
+                return;
+            const { origin } = new URL(this.iframeElement.src);
+            this.iframeElement.contentWindow.postMessage(message, origin);
+        }
+    }
+    IframeController.defaultState = {
+        isVisible: false,
+    };
+
+    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_isWalletInitialized, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+    class AirService {
+        // #walletRehydrationState: AirRehydrationResult;
+        constructor({ partnerId }) {
+            _AirService_instances.add(this);
+            _AirService_loginResult.set(this, undefined);
+            _AirService_buildEnv.set(this, undefined);
+            _AirService_enableLogging.set(this, false);
+            _AirService_partnerId.set(this, undefined);
+            //#modalZIndex: number; TODO implement z index overwrite
+            _AirService_authIframeController.set(this, undefined);
+            _AirService_isAuthInitialized.set(this, false);
+            _AirService_airAuthListener.set(this, []);
+            _AirService_walletIframeController.set(this, undefined);
+            _AirService_walletInitialization.set(this, undefined);
+            _AirService_isWalletInitialized.set(this, false);
+            _AirService_airWalletProvider.set(this, undefined);
+            __classPrivateFieldSet(this, _AirService_partnerId, partnerId, "f");
+            // this.#modalZIndex = modalZIndex ?? 99999;
+        }
+        get buildEnv() {
+            return __classPrivateFieldGet(this, _AirService_buildEnv, "f");
+        }
+        get isInitialized() {
+            return __classPrivateFieldGet(this, _AirService_isAuthInitialized, "f");
+        }
+        get isLoggedIn() {
+            return !!__classPrivateFieldGet(this, _AirService_loginResult, "f");
+        }
+        get isWalletLoaded() {
+            return __classPrivateFieldGet(this, _AirService_isWalletInitialized, "f");
+        }
+        async init({ buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, }) {
+            if (!__classPrivateFieldGet(this, _AirService_partnerId, "f"))
+                throw new Error("Partner ID is required to initialize auth service");
+            if (__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                return;
+            __classPrivateFieldSet(this, _AirService_buildEnv, buildEnv, "f");
+            __classPrivateFieldSet(this, _AirService_enableLogging, enableLogging, "f");
+            const { authUrl, logLevel } = AIR_URLS[buildEnv];
+            log.setDefaultLevel(logLevel);
+            if (__classPrivateFieldGet(this, _AirService_enableLogging, "f"))
+                log.enableAll();
+            else
+                log.disableAll();
+            const authIframeOrigin = new URL(authUrl).origin;
+            await AirMessageService$1.openAuthObservables({ authIframeOrigin });
+            __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController(authUrl, `air-auth-${randomId()}`), "f");
+            AirMessageService$1.authMessage$.subscribe(async (msg) => {
+                switch (msg.type) {
+                    case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST: {
+                        const authIframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
+                        authIframeController.setIframeVisibility(msg.payload.visible);
+                        authIframeController.updateIframeState();
+                        break;
+                    }
+                    case AirAuthMessageTypes.SETUP_WALLET_REQUEST: {
+                        try {
+                            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+                            __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
+                                type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+                                payload: {
+                                    success: true,
+                                },
+                            });
+                        }
+                        catch (err) {
+                            log.error("Error initializing wallet", err);
+                            const error = AirServiceError.from(err);
+                            __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
+                                type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+                                payload: {
+                                    success: false,
+                                    errorName: error.name ?? "UNKNOWN_ERROR",
+                                    errorMessage: error.message ?? "Unknown error occurred",
+                                },
+                            });
+                        }
+                        break;
+                    }
+                }
+            });
+            try {
+                __classPrivateFieldGet(this, _AirService_authIframeController, "f").createIframe();
+                const result = await new Promise((resolve, reject) => {
+                    const handleAuthMessage = async (ev) => {
+                        if (ev.origin !== authIframeOrigin)
+                            return;
+                        if (ev.data === AirAuthMessageTypes.AUTH_SETUP_COMPLETED) {
+                            window.removeEventListener("message", handleAuthMessage);
+                            const { payload } = await AirMessageService$1.sendAuthInitializationRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, {
+                                partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                                skipRehydration,
+                            });
+                            if (payload.success === true) {
+                                resolve(payload);
+                            }
+                            else {
+                                reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                            }
+                        }
+                    };
+                    window.addEventListener("message", handleAuthMessage);
+                });
+                __classPrivateFieldSet(this, _AirService_isAuthInitialized, true, "f");
+                __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthInitialized).call(this, { rehydrated: result.rehydrated });
+                // rehydrated auth session
+                if (result.rehydrated) {
+                    __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, result), "f");
+                    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
+                    return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+                }
+            }
+            catch (error) {
+                log.debug("Error initializing auth service", error);
+                await this.cleanUp();
+                throw error;
+            }
+            return null;
+        }
+        async cleanUp() {
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
+            this.clearEventListeners();
+        }
+        async login(options) {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            if (__classPrivateFieldGet(this, _AirService_loginResult, "f"))
+                return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+            const iframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
+            const { payload } = await AirMessageService$1.sendAuthLoginRequest(iframeController.iframeElement, {
+                partnerLoginToken: options?.authToken,
+            });
+            if (payload.success === true) {
+                __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, payload), "f");
+                __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
+                return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+            }
+            throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
+        }
+        /**
+         * @experimental This method is experimental and will change in the future.
+         */
+        async deploySmartAccount() {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            try {
+                log.info("deploySmartAccount");
+                await AirMessageService$1.sendDeploySmartAccountRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            }
+            catch (error) {
+                throw AirServiceError.from(error);
+            }
+        }
+        /**
+         * @experimental This method is experimental and will change in the future.
+         */
+        async grantPermission(policies) {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("AirAuth is not initialized");
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            try {
+                log.info("grantPermission", policies);
+                const { payload } = await AirMessageService$1.sendGrantPermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, { policies });
+                if (payload.success === false) {
+                    throw new AirServiceError(payload.errorName, payload.errorMessage);
+                }
+                return payload.sessionData;
+            }
+            catch (error) {
+                throw AirServiceError.from(error);
+            }
+        }
+        /**
+         * @experimental This method is experimental and will change in the future.
+         */
+        async executeAction(params) {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            try {
+                log.info("executeAction", params);
+                await AirMessageService$1.sendExecuteActionRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, params);
+            }
+            catch (error) {
+                throw AirServiceError.from(error);
+            }
+        }
+        /**
+         * @experimental This method is experimental and will change in the future.
+         */
+        async revokePermission(permissionId) {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            try {
+                log.info("revokePermission", permissionId);
+                await AirMessageService$1.sendRevokePermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, permissionId);
+            }
+            catch (error) {
+                throw AirServiceError.from(error);
+            }
+        }
+        async logout() {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            if (!this.isLoggedIn)
+                throw new Error("No active session to logout");
+            // Clear up wallet
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+            await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
+        }
+        async getProvider() {
+            if (!this.isLoggedIn)
+                return null;
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            return __classPrivateFieldGet(this, _AirService_airWalletProvider, "f");
+        }
+        async preloadWallet() {
+            return __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        }
+        async claimAirId(options) {
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            // return this.#realmEmbed.claimRealmId(options);
+            log.info("claimAirId", options);
+            return null;
+        }
+        async getUserInfo() {
+            if (!this.isLoggedIn)
+                throw new Error("User not logged in");
+            const info = await AirMessageService$1.sendUserInfoRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            if (info.payload.success === false) {
+                throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+            }
+            return {
+                id: info.payload.id,
+                abstractAccountAddress: info.payload.abstractAccountAddress,
+                email: info.payload.email,
+                airIds: info.payload.airIds,
+            };
+        }
+        async getPartnerUserInfo() {
+            if (!this.isLoggedIn)
+                throw new Error("User not logged in");
+            const info = await AirMessageService$1.sendPartnerUserInfoRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            if (info.payload.success === false) {
+                throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+            }
+            return {
+                partnerId: info.payload.partnerId,
+                partnerUserId: info.payload.partnerUserId,
+                airId: info.payload.airId,
+            };
+        }
+        on(listener) {
+            if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) < 0)
+                __classPrivateFieldGet(this, _AirService_airAuthListener, "f").push(listener);
+        }
+        off(listener) {
+            if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) >= 0)
+                __classPrivateFieldGet(this, _AirService_airAuthListener, "f").splice(__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener), 1);
+        }
+        clearEventListeners() {
+            __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
+        }
+        // This is for internal use only
+        // @ts-expect-error for unused function
+        async _showWalletWidget() {
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            // return (this.#realmEmbed as any)._showWalletWidget();
+            log.info("_showWalletWidget");
+            return null;
+        }
+    }
+    _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_isWalletInitialized = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet() {
+        if (!this.isInitialized)
+            throw new Error("Service not initialized");
+        if (!__classPrivateFieldGet(this, _AirService_walletInitialization, "f")) {
+            try {
+                __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeWallet).call(this), "f");
+                return await __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
+            }
+            catch (error) {
+                __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
+                log.error("Error initializing wallet", error);
+                throw error;
+            }
+        }
+        else {
+            return __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
+        }
+    }, _AirService_initializeWallet = async function _AirService_initializeWallet() {
+        if (__classPrivateFieldGet(this, _AirService_isWalletInitialized, "f"))
+            throw new AirServiceError("ALREADY_INITIALISED", "Already initialized");
+        const { walletUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
+        log.info(walletUrl, "url loaded");
+        const walletIframeOrigin = new URL(walletUrl).origin;
+        await AirMessageService$1.openWalletObservables({ walletIframeOrigin });
+        try {
+            __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
+            __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
+            AirMessageService$1.messages$.subscribe(async (msg) => {
+                switch (msg.type) {
+                    case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
+                        const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
+                        walletIframeController.setIframeVisibility(msg.payload.visible);
+                        walletIframeController.updateIframeState();
+                        break;
+                    }
+                }
+            });
+            await new Promise((resolve, reject) => {
+                const handleAuthMessage = async (ev) => {
+                    if (ev.origin !== walletIframeOrigin)
+                        return;
+                    if (ev.data === AirMessageTypes.SERVICE_STARTED) {
+                        window.removeEventListener("message", handleAuthMessage);
+                        const { payload } = await AirMessageService$1.sendWalletInitializationRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, {
+                            partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                            enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                        });
+                        if (payload.success === true) {
+                            resolve();
+                        }
+                        else {
+                            reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                        }
+                    }
+                };
+                window.addEventListener("message", handleAuthMessage);
+            });
+            const walletInitPromise = AirMessageService$1.onWalletInitialized();
+            AirMessageService$1.setupIframeCommunication(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, __classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            const walletInitResult = await walletInitPromise;
+            if (walletInitResult.payload.success !== true) {
+                throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
+            }
+            __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement), "f");
+            const result = {
+                abstractAccountAddress: walletInitResult.payload.addresses.aa,
+            };
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, result);
+            return result;
+        }
+        catch (error) {
+            log.error("Error initializing wallet", error);
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+            throw error;
+        }
+    }, _AirService_triggerEventListeners = function _AirService_triggerEventListeners(data) {
+        __classPrivateFieldGet(this, _AirService_airAuthListener, "f").forEach((listener) => {
+            listener(data);
+        });
+    }, _AirService_triggerAirAuthInitialized = function _AirService_triggerAirAuthInitialized(result) {
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, { event: "initialized", result });
+    }, _AirService_triggerAirAuthLoggedIn = function _AirService_triggerAirAuthLoggedIn() {
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+            event: "logged_in",
+            result: __classPrivateFieldGet(this, _AirService_loginResult, "f"),
+        });
+    }, _AirService_triggerAirAuthLoggedOut = function _AirService_triggerAirAuthLoggedOut() {
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, { event: "logged_out" });
+    }, _AirService_triggerWalletInitialized = function _AirService_triggerWalletInitialized(result) {
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+            event: "wallet_initialized",
+            result,
+        });
+    }, _AirService_createLoginResult = function _AirService_createLoginResult(payload) {
+        return {
+            isLoggedIn: true,
+            id: payload.id,
+            abstractAccountAddress: payload.abstractAccountAddress,
+            token: payload.partnerAccessToken,
+        };
+    }, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
+        // Logout auth session
+        await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        // Destroy the auth iframe
+        const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
+        if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+            __classPrivateFieldGet(this, _AirService_authIframeController, "f").destroy();
+            __classPrivateFieldSet(this, _AirService_authIframeController, undefined, "f");
+        }
+        // Close the message service
+        AirMessageService$1.closeAuthObservables();
+        __classPrivateFieldSet(this, _AirService_isAuthInitialized, false, "f");
+    }, _AirService_cleanUpWallet = async function _AirService_cleanUpWallet() {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            return;
+        // Logout wallet session
+        // TODO need to tell wallet to clear preferences?
+        // Destroy the wallet iframe
+        const walletIframeElement = __classPrivateFieldGet(this, _AirService_walletIframeController, "f")?.iframeElement;
+        if (isElement(walletIframeElement) && window.document.body.contains(walletIframeElement)) {
+            __classPrivateFieldGet(this, _AirService_walletIframeController, "f").destroy();
+            __classPrivateFieldSet(this, _AirService_walletIframeController, undefined, "f");
+        }
+        // Close the message service
+        AirMessageService$1.closeAirObservables();
+        __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
+        __classPrivateFieldSet(this, _AirService_isWalletInitialized, false, "f");
+    };
+
+    exports.AirService = AirService;
+    exports.AirWalletProvider = AirWalletProvider;
+    exports.BUILD_ENV = BUILD_ENV;
+
+}));