aws-appsync-subscription-link 3.1.2 → 3.1.4

package/lib/index.mjs

@@ -0,0 +1,3631 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self1) {
+    if (self1 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self1;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self1 = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self1, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _possible_constructor_return(self1, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self1);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _to_primitive(input, hint) {
+    if (_type_of(input) !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+        var res = prim.call(input, hint || "default");
+        if (_type_of(res) !== "object") return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+}
+function _to_property_key(arg) {
+    var key = _to_primitive(arg, "string");
+    return _type_of(key) === "symbol" ? key : String(key);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, 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] : void 0,
+            done: true
+        };
+    }
+}
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = function(cb, mod) {
+    return function __require() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+            exports: {}
+        }).exports, mod), mod.exports;
+    };
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+// src/vendor/paho-mqtt.js
+var require_paho_mqtt = __commonJS({
+    "src/vendor/paho-mqtt.js": function(exports, module) {
+        (function ExportLibrary(root, factory) {
+            if ((typeof exports === "undefined" ? "undefined" : _type_of(exports)) === "object" && (typeof module === "undefined" ? "undefined" : _type_of(module)) === "object") {
+                module.exports = factory();
+            } else if (typeof define === "function" && define.amd) {
+                define(factory);
+            } else if ((typeof exports === "undefined" ? "undefined" : _type_of(exports)) === "object") {
+                exports = factory();
+            } else {
+                root.Paho = factory();
+            }
+        })(exports, function LibraryFactory() {
+            var PahoMQTT = function(global2) {
+                var version = "@VERSION@-@BUILDLEVEL@";
+                var localStorage = global2.localStorage || /* @__PURE__ */ function() {
+                    var data = {};
+                    return {
+                        setItem: function setItem(key, item) {
+                            data[key] = item;
+                        },
+                        getItem: function getItem(key) {
+                            return data[key];
+                        },
+                        removeItem: function removeItem(key) {
+                            delete data[key];
+                        }
+                    };
+                }();
+                var MESSAGE_TYPE = {
+                    CONNECT: 1,
+                    CONNACK: 2,
+                    PUBLISH: 3,
+                    PUBACK: 4,
+                    PUBREC: 5,
+                    PUBREL: 6,
+                    PUBCOMP: 7,
+                    SUBSCRIBE: 8,
+                    SUBACK: 9,
+                    UNSUBSCRIBE: 10,
+                    UNSUBACK: 11,
+                    PINGREQ: 12,
+                    PINGRESP: 13,
+                    DISCONNECT: 14
+                };
+                var validate = function validate(obj, keys) {
+                    for(var key in obj){
+                        if (obj.hasOwnProperty(key)) {
+                            if (keys.hasOwnProperty(key)) {
+                                if (_type_of(obj[key]) !== keys[key]) throw new Error(format(ERROR.INVALID_TYPE, [
+                                    _type_of(obj[key]),
+                                    key
+                                ]));
+                            } else {
+                                var errorStr = "Unknown property, " + key + ". Valid properties are:";
+                                for(var validKey in keys)if (keys.hasOwnProperty(validKey)) errorStr = errorStr + " " + validKey;
+                                throw new Error(errorStr);
+                            }
+                        }
+                    }
+                };
+                var scope = function scope(f, scope2) {
+                    return function() {
+                        return f.apply(scope2, arguments);
+                    };
+                };
+                var ERROR = {
+                    OK: {
+                        code: 0,
+                        text: "AMQJSC0000I OK."
+                    },
+                    CONNECT_TIMEOUT: {
+                        code: 1,
+                        text: "AMQJSC0001E Connect timed out."
+                    },
+                    SUBSCRIBE_TIMEOUT: {
+                        code: 2,
+                        text: "AMQJS0002E Subscribe timed out."
+                    },
+                    UNSUBSCRIBE_TIMEOUT: {
+                        code: 3,
+                        text: "AMQJS0003E Unsubscribe timed out."
+                    },
+                    PING_TIMEOUT: {
+                        code: 4,
+                        text: "AMQJS0004E Ping timed out."
+                    },
+                    INTERNAL_ERROR: {
+                        code: 5,
+                        text: "AMQJS0005E Internal error. Error Message: {0}, Stack trace: {1}"
+                    },
+                    CONNACK_RETURNCODE: {
+                        code: 6,
+                        text: "AMQJS0006E Bad Connack return code:{0} {1}."
+                    },
+                    SOCKET_ERROR: {
+                        code: 7,
+                        text: "AMQJS0007E Socket error:{0}."
+                    },
+                    SOCKET_CLOSE: {
+                        code: 8,
+                        text: "AMQJS0008I Socket closed."
+                    },
+                    MALFORMED_UTF: {
+                        code: 9,
+                        text: "AMQJS0009E Malformed UTF data:{0} {1} {2}."
+                    },
+                    UNSUPPORTED: {
+                        code: 10,
+                        text: "AMQJS0010E {0} is not supported by this browser."
+                    },
+                    INVALID_STATE: {
+                        code: 11,
+                        text: "AMQJS0011E Invalid state {0}."
+                    },
+                    INVALID_TYPE: {
+                        code: 12,
+                        text: "AMQJS0012E Invalid type {0} for {1}."
+                    },
+                    INVALID_ARGUMENT: {
+                        code: 13,
+                        text: "AMQJS0013E Invalid argument {0} for {1}."
+                    },
+                    UNSUPPORTED_OPERATION: {
+                        code: 14,
+                        text: "AMQJS0014E Unsupported operation."
+                    },
+                    INVALID_STORED_DATA: {
+                        code: 15,
+                        text: "AMQJS0015E Invalid data in local storage key={0} value={1}."
+                    },
+                    INVALID_MQTT_MESSAGE_TYPE: {
+                        code: 16,
+                        text: "AMQJS0016E Invalid MQTT message type {0}."
+                    },
+                    MALFORMED_UNICODE: {
+                        code: 17,
+                        text: "AMQJS0017E Malformed Unicode string:{0} {1}."
+                    },
+                    BUFFER_FULL: {
+                        code: 18,
+                        text: "AMQJS0018E Message buffer is full, maximum buffer size: {0}."
+                    }
+                };
+                var CONNACK_RC = {
+                    0: "Connection Accepted",
+                    1: "Connection Refused: unacceptable protocol version",
+                    2: "Connection Refused: identifier rejected",
+                    3: "Connection Refused: server unavailable",
+                    4: "Connection Refused: bad user name or password",
+                    5: "Connection Refused: not authorized"
+                };
+                var format = function format(error, substitutions) {
+                    var text = error.text;
+                    if (substitutions) {
+                        var field, start;
+                        for(var i = 0; i < substitutions.length; i++){
+                            field = "{" + i + "}";
+                            start = text.indexOf(field);
+                            if (start > 0) {
+                                var part1 = text.substring(0, start);
+                                var part2 = text.substring(start + field.length);
+                                text = part1 + substitutions[i] + part2;
+                            }
+                        }
+                    }
+                    return text;
+                };
+                var MqttProtoIdentifierv3 = [
+                    0,
+                    6,
+                    77,
+                    81,
+                    73,
+                    115,
+                    100,
+                    112,
+                    3
+                ];
+                var MqttProtoIdentifierv4 = [
+                    0,
+                    4,
+                    77,
+                    81,
+                    84,
+                    84,
+                    4
+                ];
+                var WireMessage = function WireMessage(type, options) {
+                    this.type = type;
+                    for(var name in options){
+                        if (options.hasOwnProperty(name)) {
+                            this[name] = options[name];
+                        }
+                    }
+                };
+                WireMessage.prototype.encode = function() {
+                    var first = (this.type & 15) << 4;
+                    var remLength = 0;
+                    var topicStrLength = [];
+                    var destinationNameLength = 0;
+                    var willMessagePayloadBytes;
+                    if (this.messageIdentifier !== void 0) remLength += 2;
+                    switch(this.type){
+                        // If this a Connect then we need to include 12 bytes for its header
+                        case MESSAGE_TYPE.CONNECT:
+                            switch(this.mqttVersion){
+                                case 3:
+                                    remLength += MqttProtoIdentifierv3.length + 3;
+                                    break;
+                                case 4:
+                                    remLength += MqttProtoIdentifierv4.length + 3;
+                                    break;
+                            }
+                            remLength += UTF8Length(this.clientId) + 2;
+                            if (this.willMessage !== void 0) {
+                                remLength += UTF8Length(this.willMessage.destinationName) + 2;
+                                willMessagePayloadBytes = this.willMessage.payloadBytes;
+                                if (!_instanceof(willMessagePayloadBytes, Uint8Array)) willMessagePayloadBytes = new Uint8Array(payloadBytes);
+                                remLength += willMessagePayloadBytes.byteLength + 2;
+                            }
+                            if (this.userName !== void 0) remLength += UTF8Length(this.userName) + 2;
+                            if (this.password !== void 0) remLength += UTF8Length(this.password) + 2;
+                            break;
+                        // Subscribe, Unsubscribe can both contain topic strings
+                        case MESSAGE_TYPE.SUBSCRIBE:
+                            first |= 2;
+                            for(var i = 0; i < this.topics.length; i++){
+                                topicStrLength[i] = UTF8Length(this.topics[i]);
+                                remLength += topicStrLength[i] + 2;
+                            }
+                            remLength += this.requestedQos.length;
+                            break;
+                        case MESSAGE_TYPE.UNSUBSCRIBE:
+                            first |= 2;
+                            for(var i = 0; i < this.topics.length; i++){
+                                topicStrLength[i] = UTF8Length(this.topics[i]);
+                                remLength += topicStrLength[i] + 2;
+                            }
+                            break;
+                        case MESSAGE_TYPE.PUBREL:
+                            first |= 2;
+                            break;
+                        case MESSAGE_TYPE.PUBLISH:
+                            if (this.payloadMessage.duplicate) first |= 8;
+                            first = first |= this.payloadMessage.qos << 1;
+                            if (this.payloadMessage.retained) first |= 1;
+                            destinationNameLength = UTF8Length(this.payloadMessage.destinationName);
+                            remLength += destinationNameLength + 2;
+                            var payloadBytes = this.payloadMessage.payloadBytes;
+                            remLength += payloadBytes.byteLength;
+                            if (_instanceof(payloadBytes, ArrayBuffer)) payloadBytes = new Uint8Array(payloadBytes);
+                            else if (!_instanceof(payloadBytes, Uint8Array)) payloadBytes = new Uint8Array(payloadBytes.buffer);
+                            break;
+                        case MESSAGE_TYPE.DISCONNECT:
+                            break;
+                        default:
+                            break;
+                    }
+                    var mbi = encodeMBI(remLength);
+                    var pos = mbi.length + 1;
+                    var buffer = new ArrayBuffer(remLength + pos);
+                    var byteStream = new Uint8Array(buffer);
+                    byteStream[0] = first;
+                    byteStream.set(mbi, 1);
+                    if (this.type == MESSAGE_TYPE.PUBLISH) pos = writeString(this.payloadMessage.destinationName, destinationNameLength, byteStream, pos);
+                    else if (this.type == MESSAGE_TYPE.CONNECT) {
+                        switch(this.mqttVersion){
+                            case 3:
+                                byteStream.set(MqttProtoIdentifierv3, pos);
+                                pos += MqttProtoIdentifierv3.length;
+                                break;
+                            case 4:
+                                byteStream.set(MqttProtoIdentifierv4, pos);
+                                pos += MqttProtoIdentifierv4.length;
+                                break;
+                        }
+                        var connectFlags = 0;
+                        if (this.cleanSession) connectFlags = 2;
+                        if (this.willMessage !== void 0) {
+                            connectFlags |= 4;
+                            connectFlags |= this.willMessage.qos << 3;
+                            if (this.willMessage.retained) {
+                                connectFlags |= 32;
+                            }
+                        }
+                        if (this.userName !== void 0) connectFlags |= 128;
+                        if (this.password !== void 0) connectFlags |= 64;
+                        byteStream[pos++] = connectFlags;
+                        pos = writeUint16(this.keepAliveInterval, byteStream, pos);
+                    }
+                    if (this.messageIdentifier !== void 0) pos = writeUint16(this.messageIdentifier, byteStream, pos);
+                    switch(this.type){
+                        case MESSAGE_TYPE.CONNECT:
+                            pos = writeString(this.clientId, UTF8Length(this.clientId), byteStream, pos);
+                            if (this.willMessage !== void 0) {
+                                pos = writeString(this.willMessage.destinationName, UTF8Length(this.willMessage.destinationName), byteStream, pos);
+                                pos = writeUint16(willMessagePayloadBytes.byteLength, byteStream, pos);
+                                byteStream.set(willMessagePayloadBytes, pos);
+                                pos += willMessagePayloadBytes.byteLength;
+                            }
+                            if (this.userName !== void 0) pos = writeString(this.userName, UTF8Length(this.userName), byteStream, pos);
+                            if (this.password !== void 0) pos = writeString(this.password, UTF8Length(this.password), byteStream, pos);
+                            break;
+                        case MESSAGE_TYPE.PUBLISH:
+                            byteStream.set(payloadBytes, pos);
+                            break;
+                        //    	    case MESSAGE_TYPE.PUBREC:
+                        //    	    case MESSAGE_TYPE.PUBREL:
+                        //    	    case MESSAGE_TYPE.PUBCOMP:
+                        //    	    	break;
+                        case MESSAGE_TYPE.SUBSCRIBE:
+                            for(var i = 0; i < this.topics.length; i++){
+                                pos = writeString(this.topics[i], topicStrLength[i], byteStream, pos);
+                                byteStream[pos++] = this.requestedQos[i];
+                            }
+                            break;
+                        case MESSAGE_TYPE.UNSUBSCRIBE:
+                            for(var i = 0; i < this.topics.length; i++)pos = writeString(this.topics[i], topicStrLength[i], byteStream, pos);
+                            break;
+                        default:
+                    }
+                    return buffer;
+                };
+                function decodeMessage(input, pos) {
+                    var startingPos = pos;
+                    var first = input[pos];
+                    var type = first >> 4;
+                    var messageInfo = first &= 15;
+                    pos += 1;
+                    var digit;
+                    var remLength = 0;
+                    var multiplier = 1;
+                    do {
+                        if (pos == input.length) {
+                            return [
+                                null,
+                                startingPos
+                            ];
+                        }
+                        digit = input[pos++];
+                        remLength += (digit & 127) * multiplier;
+                        multiplier *= 128;
+                    }while ((digit & 128) !== 0);
+                    var endPos = pos + remLength;
+                    if (endPos > input.length) {
+                        return [
+                            null,
+                            startingPos
+                        ];
+                    }
+                    var wireMessage = new WireMessage(type);
+                    switch(type){
+                        case MESSAGE_TYPE.CONNACK:
+                            var connectAcknowledgeFlags = input[pos++];
+                            if (connectAcknowledgeFlags & 1) wireMessage.sessionPresent = true;
+                            wireMessage.returnCode = input[pos++];
+                            break;
+                        case MESSAGE_TYPE.PUBLISH:
+                            var qos = messageInfo >> 1 & 3;
+                            var len = readUint16(input, pos);
+                            pos += 2;
+                            var topicName = parseUTF8(input, pos, len);
+                            pos += len;
+                            if (qos > 0) {
+                                wireMessage.messageIdentifier = readUint16(input, pos);
+                                pos += 2;
+                            }
+                            var message = new PahoMQTT.Message(input.subarray(pos, endPos));
+                            if ((messageInfo & 1) == 1) message.retained = true;
+                            if ((messageInfo & 8) == 8) message.duplicate = true;
+                            message.qos = qos;
+                            message.destinationName = topicName;
+                            wireMessage.payloadMessage = message;
+                            break;
+                        case MESSAGE_TYPE.PUBACK:
+                        case MESSAGE_TYPE.PUBREC:
+                        case MESSAGE_TYPE.PUBREL:
+                        case MESSAGE_TYPE.PUBCOMP:
+                        case MESSAGE_TYPE.UNSUBACK:
+                            wireMessage.messageIdentifier = readUint16(input, pos);
+                            break;
+                        case MESSAGE_TYPE.SUBACK:
+                            wireMessage.messageIdentifier = readUint16(input, pos);
+                            pos += 2;
+                            wireMessage.returnCode = input.subarray(pos, endPos);
+                            break;
+                        default:
+                            break;
+                    }
+                    return [
+                        wireMessage,
+                        endPos
+                    ];
+                }
+                function writeUint16(input, buffer, offset) {
+                    buffer[offset++] = input >> 8;
+                    buffer[offset++] = input % 256;
+                    return offset;
+                }
+                function writeString(input, utf8Length, buffer, offset) {
+                    offset = writeUint16(utf8Length, buffer, offset);
+                    stringToUTF8(input, buffer, offset);
+                    return offset + utf8Length;
+                }
+                function readUint16(buffer, offset) {
+                    return 256 * buffer[offset] + buffer[offset + 1];
+                }
+                function encodeMBI(number) {
+                    var output = new Array(1);
+                    var numBytes = 0;
+                    do {
+                        var digit = number % 128;
+                        number = number >> 7;
+                        if (number > 0) {
+                            digit |= 128;
+                        }
+                        output[numBytes++] = digit;
+                    }while (number > 0 && numBytes < 4);
+                    return output;
+                }
+                function UTF8Length(input) {
+                    var output = 0;
+                    for(var i = 0; i < input.length; i++){
+                        var charCode = input.charCodeAt(i);
+                        if (charCode > 2047) {
+                            if (55296 <= charCode && charCode <= 56319) {
+                                i++;
+                                output++;
+                            }
+                            output += 3;
+                        } else if (charCode > 127) output += 2;
+                        else output++;
+                    }
+                    return output;
+                }
+                function stringToUTF8(input, output, start) {
+                    var pos = start;
+                    for(var i = 0; i < input.length; i++){
+                        var charCode = input.charCodeAt(i);
+                        if (55296 <= charCode && charCode <= 56319) {
+                            var lowCharCode = input.charCodeAt(++i);
+                            if (isNaN(lowCharCode)) {
+                                throw new Error(format(ERROR.MALFORMED_UNICODE, [
+                                    charCode,
+                                    lowCharCode
+                                ]));
+                            }
+                            charCode = (charCode - 55296 << 10) + (lowCharCode - 56320) + 65536;
+                        }
+                        if (charCode <= 127) {
+                            output[pos++] = charCode;
+                        } else if (charCode <= 2047) {
+                            output[pos++] = charCode >> 6 & 31 | 192;
+                            output[pos++] = charCode & 63 | 128;
+                        } else if (charCode <= 65535) {
+                            output[pos++] = charCode >> 12 & 15 | 224;
+                            output[pos++] = charCode >> 6 & 63 | 128;
+                            output[pos++] = charCode & 63 | 128;
+                        } else {
+                            output[pos++] = charCode >> 18 & 7 | 240;
+                            output[pos++] = charCode >> 12 & 63 | 128;
+                            output[pos++] = charCode >> 6 & 63 | 128;
+                            output[pos++] = charCode & 63 | 128;
+                        }
+                    }
+                    return output;
+                }
+                function parseUTF8(input, offset, length) {
+                    var output = "";
+                    var utf16;
+                    var pos = offset;
+                    while(pos < offset + length){
+                        var byte1 = input[pos++];
+                        if (byte1 < 128) utf16 = byte1;
+                        else {
+                            var byte2 = input[pos++] - 128;
+                            if (byte2 < 0) throw new Error(format(ERROR.MALFORMED_UTF, [
+                                byte1.toString(16),
+                                byte2.toString(16),
+                                ""
+                            ]));
+                            if (byte1 < 224) utf16 = 64 * (byte1 - 192) + byte2;
+                            else {
+                                var byte3 = input[pos++] - 128;
+                                if (byte3 < 0) throw new Error(format(ERROR.MALFORMED_UTF, [
+                                    byte1.toString(16),
+                                    byte2.toString(16),
+                                    byte3.toString(16)
+                                ]));
+                                if (byte1 < 240) utf16 = 4096 * (byte1 - 224) + 64 * byte2 + byte3;
+                                else {
+                                    var byte4 = input[pos++] - 128;
+                                    if (byte4 < 0) throw new Error(format(ERROR.MALFORMED_UTF, [
+                                        byte1.toString(16),
+                                        byte2.toString(16),
+                                        byte3.toString(16),
+                                        byte4.toString(16)
+                                    ]));
+                                    if (byte1 < 248) utf16 = 262144 * (byte1 - 240) + 4096 * byte2 + 64 * byte3 + byte4;
+                                    else throw new Error(format(ERROR.MALFORMED_UTF, [
+                                        byte1.toString(16),
+                                        byte2.toString(16),
+                                        byte3.toString(16),
+                                        byte4.toString(16)
+                                    ]));
+                                }
+                            }
+                        }
+                        if (utf16 > 65535) {
+                            utf16 -= 65536;
+                            output += String.fromCharCode(55296 + (utf16 >> 10));
+                            utf16 = 56320 + (utf16 & 1023);
+                        }
+                        output += String.fromCharCode(utf16);
+                    }
+                    return output;
+                }
+                var Pinger = function Pinger(client, keepAliveInterval) {
+                    this._client = client;
+                    this._keepAliveInterval = keepAliveInterval * 1e3;
+                    this.isReset = false;
+                    var pingReq = new WireMessage(MESSAGE_TYPE.PINGREQ).encode();
+                    var doTimeout = function doTimeout(pinger) {
+                        return function() {
+                            return doPing.apply(pinger);
+                        };
+                    };
+                    var doPing = function doPing() {
+                        if (!this.isReset) {
+                            this._client._trace("Pinger.doPing", "Timed out");
+                            this._client._disconnected(ERROR.PING_TIMEOUT.code, format(ERROR.PING_TIMEOUT));
+                        } else {
+                            this.isReset = false;
+                            this._client._trace("Pinger.doPing", "send PINGREQ");
+                            this._client.socket.send(pingReq);
+                            this.timeout = setTimeout(doTimeout(this), this._keepAliveInterval);
+                        }
+                    };
+                    this.reset = function() {
+                        this.isReset = true;
+                        clearTimeout(this.timeout);
+                        if (this._keepAliveInterval > 0) this.timeout = setTimeout(doTimeout(this), this._keepAliveInterval);
+                    };
+                    this.cancel = function() {
+                        clearTimeout(this.timeout);
+                    };
+                };
+                var Timeout = function Timeout(client, timeoutSeconds, action, args) {
+                    if (!timeoutSeconds) timeoutSeconds = 30;
+                    var doTimeout = function doTimeout(action2, client2, args2) {
+                        return function() {
+                            return action2.apply(client2, args2);
+                        };
+                    };
+                    this.timeout = setTimeout(doTimeout(action, client, args), timeoutSeconds * 1e3);
+                    this.cancel = function() {
+                        clearTimeout(this.timeout);
+                    };
+                };
+                var ClientImpl = function ClientImpl(uri, host, port, path, clientId) {
+                    if (!("WebSocket" in global2 && global2.WebSocket !== null)) {
+                        throw new Error(format(ERROR.UNSUPPORTED, [
+                            "WebSocket"
+                        ]));
+                    }
+                    if (!("ArrayBuffer" in global2 && global2.ArrayBuffer !== null)) {
+                        throw new Error(format(ERROR.UNSUPPORTED, [
+                            "ArrayBuffer"
+                        ]));
+                    }
+                    this._trace("Paho.Client", uri, host, port, path, clientId);
+                    this.host = host;
+                    this.port = port;
+                    this.path = path;
+                    this.uri = uri;
+                    this.clientId = clientId;
+                    this._wsuri = null;
+                    this._localKey = host + ":" + port + (path != "/mqtt" ? ":" + path : "") + ":" + clientId + ":";
+                    this._msg_queue = [];
+                    this._buffered_msg_queue = [];
+                    this._sentMessages = {};
+                    this._receivedMessages = {};
+                    this._notify_msg_sent = {};
+                    this._message_identifier = 1;
+                    this._sequence = 0;
+                    for(var key in localStorage)if (key.indexOf("Sent:" + this._localKey) === 0 || key.indexOf("Received:" + this._localKey) === 0) this.restore(key);
+                };
+                ClientImpl.prototype.host = null;
+                ClientImpl.prototype.port = null;
+                ClientImpl.prototype.path = null;
+                ClientImpl.prototype.uri = null;
+                ClientImpl.prototype.clientId = null;
+                ClientImpl.prototype.socket = null;
+                ClientImpl.prototype.connected = false;
+                ClientImpl.prototype.maxMessageIdentifier = 65536;
+                ClientImpl.prototype.connectOptions = null;
+                ClientImpl.prototype.hostIndex = null;
+                ClientImpl.prototype.onConnected = null;
+                ClientImpl.prototype.onConnectionLost = null;
+                ClientImpl.prototype.onMessageDelivered = null;
+                ClientImpl.prototype.onMessageArrived = null;
+                ClientImpl.prototype.traceFunction = null;
+                ClientImpl.prototype._msg_queue = null;
+                ClientImpl.prototype._buffered_msg_queue = null;
+                ClientImpl.prototype._connectTimeout = null;
+                ClientImpl.prototype.sendPinger = null;
+                ClientImpl.prototype.receivePinger = null;
+                ClientImpl.prototype._reconnectInterval = 1;
+                ClientImpl.prototype._reconnecting = false;
+                ClientImpl.prototype._reconnectTimeout = null;
+                ClientImpl.prototype.disconnectedPublishing = false;
+                ClientImpl.prototype.disconnectedBufferSize = 5e3;
+                ClientImpl.prototype.receiveBuffer = null;
+                ClientImpl.prototype._traceBuffer = null;
+                ClientImpl.prototype._MAX_TRACE_ENTRIES = 100;
+                ClientImpl.prototype.connect = function(connectOptions) {
+                    var connectOptionsMasked = this._traceMask(connectOptions, "password");
+                    this._trace("Client.connect", connectOptionsMasked, this.socket, this.connected);
+                    if (this.connected) throw new Error(format(ERROR.INVALID_STATE, [
+                        "already connected"
+                    ]));
+                    if (this.socket) throw new Error(format(ERROR.INVALID_STATE, [
+                        "already connected"
+                    ]));
+                    if (this._reconnecting) {
+                        this._reconnectTimeout.cancel();
+                        this._reconnectTimeout = null;
+                        this._reconnecting = false;
+                    }
+                    this.connectOptions = connectOptions;
+                    this._reconnectInterval = 1;
+                    this._reconnecting = false;
+                    if (connectOptions.uris) {
+                        this.hostIndex = 0;
+                        this._doConnect(connectOptions.uris[0]);
+                    } else {
+                        this._doConnect(this.uri);
+                    }
+                };
+                ClientImpl.prototype.subscribe = function(filter3, subscribeOptions) {
+                    this._trace("Client.subscribe", filter3, subscribeOptions);
+                    if (!this.connected) throw new Error(format(ERROR.INVALID_STATE, [
+                        "not connected"
+                    ]));
+                    var wireMessage = new WireMessage(MESSAGE_TYPE.SUBSCRIBE);
+                    wireMessage.topics = [
+                        filter3
+                    ];
+                    if (subscribeOptions.qos !== void 0) wireMessage.requestedQos = [
+                        subscribeOptions.qos
+                    ];
+                    else wireMessage.requestedQos = [
+                        0
+                    ];
+                    if (subscribeOptions.onSuccess) {
+                        wireMessage.onSuccess = function(grantedQos) {
+                            subscribeOptions.onSuccess({
+                                invocationContext: subscribeOptions.invocationContext,
+                                grantedQos: grantedQos
+                            });
+                        };
+                    }
+                    if (subscribeOptions.onFailure) {
+                        wireMessage.onFailure = function(errorCode) {
+                            subscribeOptions.onFailure({
+                                invocationContext: subscribeOptions.invocationContext,
+                                errorCode: errorCode,
+                                errorMessage: format(errorCode)
+                            });
+                        };
+                    }
+                    if (subscribeOptions.timeout) {
+                        wireMessage.timeOut = new Timeout(this, subscribeOptions.timeout, subscribeOptions.onFailure, [
+                            {
+                                invocationContext: subscribeOptions.invocationContext,
+                                errorCode: ERROR.SUBSCRIBE_TIMEOUT.code,
+                                errorMessage: format(ERROR.SUBSCRIBE_TIMEOUT)
+                            }
+                        ]);
+                    }
+                    this._requires_ack(wireMessage);
+                    this._schedule_message(wireMessage);
+                };
+                ClientImpl.prototype.unsubscribe = function(filter3, unsubscribeOptions) {
+                    this._trace("Client.unsubscribe", filter3, unsubscribeOptions);
+                    if (!this.connected) throw new Error(format(ERROR.INVALID_STATE, [
+                        "not connected"
+                    ]));
+                    var wireMessage = new WireMessage(MESSAGE_TYPE.UNSUBSCRIBE);
+                    wireMessage.topics = [
+                        filter3
+                    ];
+                    if (unsubscribeOptions.onSuccess) {
+                        wireMessage.callback = function() {
+                            unsubscribeOptions.onSuccess({
+                                invocationContext: unsubscribeOptions.invocationContext
+                            });
+                        };
+                    }
+                    if (unsubscribeOptions.timeout) {
+                        wireMessage.timeOut = new Timeout(this, unsubscribeOptions.timeout, unsubscribeOptions.onFailure, [
+                            {
+                                invocationContext: unsubscribeOptions.invocationContext,
+                                errorCode: ERROR.UNSUBSCRIBE_TIMEOUT.code,
+                                errorMessage: format(ERROR.UNSUBSCRIBE_TIMEOUT)
+                            }
+                        ]);
+                    }
+                    this._requires_ack(wireMessage);
+                    this._schedule_message(wireMessage);
+                };
+                ClientImpl.prototype.send = function(message) {
+                    this._trace("Client.send", message);
+                    var wireMessage = new WireMessage(MESSAGE_TYPE.PUBLISH);
+                    wireMessage.payloadMessage = message;
+                    if (this.connected) {
+                        if (message.qos > 0) {
+                            this._requires_ack(wireMessage);
+                        } else if (this.onMessageDelivered) {
+                            this._notify_msg_sent[wireMessage] = this.onMessageDelivered(wireMessage.payloadMessage);
+                        }
+                        this._schedule_message(wireMessage);
+                    } else {
+                        if (this._reconnecting && this.disconnectedPublishing) {
+                            var messageCount = Object.keys(this._sentMessages).length + this._buffered_msg_queue.length;
+                            if (messageCount > this.disconnectedBufferSize) {
+                                throw new Error(format(ERROR.BUFFER_FULL, [
+                                    this.disconnectedBufferSize
+                                ]));
+                            } else {
+                                if (message.qos > 0) {
+                                    this._requires_ack(wireMessage);
+                                } else {
+                                    wireMessage.sequence = ++this._sequence;
+                                    this._buffered_msg_queue.unshift(wireMessage);
+                                }
+                            }
+                        } else {
+                            throw new Error(format(ERROR.INVALID_STATE, [
+                                "not connected"
+                            ]));
+                        }
+                    }
+                };
+                ClientImpl.prototype.disconnect = function() {
+                    this._trace("Client.disconnect");
+                    if (this._reconnecting) {
+                        this._reconnectTimeout.cancel();
+                        this._reconnectTimeout = null;
+                        this._reconnecting = false;
+                    }
+                    if (!this.socket) throw new Error(format(ERROR.INVALID_STATE, [
+                        "not connecting or connected"
+                    ]));
+                    var wireMessage = new WireMessage(MESSAGE_TYPE.DISCONNECT);
+                    this._notify_msg_sent[wireMessage] = scope(this._disconnected, this);
+                    this._schedule_message(wireMessage);
+                };
+                ClientImpl.prototype.getTraceLog = function() {
+                    if (this._traceBuffer !== null) {
+                        this._trace("Client.getTraceLog", /* @__PURE__ */ new Date());
+                        this._trace("Client.getTraceLog in flight messages", this._sentMessages.length);
+                        for(var key in this._sentMessages)this._trace("_sentMessages ", key, this._sentMessages[key]);
+                        for(var key in this._receivedMessages)this._trace("_receivedMessages ", key, this._receivedMessages[key]);
+                        return this._traceBuffer;
+                    }
+                };
+                ClientImpl.prototype.startTrace = function() {
+                    if (this._traceBuffer === null) {
+                        this._traceBuffer = [];
+                    }
+                    this._trace("Client.startTrace", /* @__PURE__ */ new Date(), version);
+                };
+                ClientImpl.prototype.stopTrace = function() {
+                    delete this._traceBuffer;
+                };
+                ClientImpl.prototype._doConnect = function(wsurl) {
+                    if (this.connectOptions.useSSL) {
+                        var uriParts = wsurl.split(":");
+                        uriParts[0] = "wss";
+                        wsurl = uriParts.join(":");
+                    }
+                    this._wsuri = wsurl;
+                    this.connected = false;
+                    if (this.connectOptions.mqttVersion < 4) {
+                        this.socket = new WebSocket(wsurl, [
+                            "mqttv3.1"
+                        ]);
+                    } else {
+                        this.socket = new WebSocket(wsurl, [
+                            "mqtt"
+                        ]);
+                    }
+                    this.socket.binaryType = "arraybuffer";
+                    this.socket.onopen = scope(this._on_socket_open, this);
+                    this.socket.onmessage = scope(this._on_socket_message, this);
+                    this.socket.onerror = scope(this._on_socket_error, this);
+                    this.socket.onclose = scope(this._on_socket_close, this);
+                    this.sendPinger = new Pinger(this, this.connectOptions.keepAliveInterval);
+                    this.receivePinger = new Pinger(this, this.connectOptions.keepAliveInterval);
+                    if (this._connectTimeout) {
+                        this._connectTimeout.cancel();
+                        this._connectTimeout = null;
+                    }
+                    this._connectTimeout = new Timeout(this, this.connectOptions.timeout, this._disconnected, [
+                        ERROR.CONNECT_TIMEOUT.code,
+                        format(ERROR.CONNECT_TIMEOUT)
+                    ]);
+                };
+                ClientImpl.prototype._schedule_message = function(message) {
+                    this._msg_queue.unshift(message);
+                    if (this.connected) {
+                        this._process_queue();
+                    }
+                };
+                ClientImpl.prototype.store = function(prefix, wireMessage) {
+                    var storedMessage = {
+                        type: wireMessage.type,
+                        messageIdentifier: wireMessage.messageIdentifier,
+                        version: 1
+                    };
+                    switch(wireMessage.type){
+                        case MESSAGE_TYPE.PUBLISH:
+                            if (wireMessage.pubRecReceived) storedMessage.pubRecReceived = true;
+                            storedMessage.payloadMessage = {};
+                            var hex = "";
+                            var messageBytes = wireMessage.payloadMessage.payloadBytes;
+                            for(var i = 0; i < messageBytes.length; i++){
+                                if (messageBytes[i] <= 15) hex = hex + "0" + messageBytes[i].toString(16);
+                                else hex = hex + messageBytes[i].toString(16);
+                            }
+                            storedMessage.payloadMessage.payloadHex = hex;
+                            storedMessage.payloadMessage.qos = wireMessage.payloadMessage.qos;
+                            storedMessage.payloadMessage.destinationName = wireMessage.payloadMessage.destinationName;
+                            if (wireMessage.payloadMessage.duplicate) storedMessage.payloadMessage.duplicate = true;
+                            if (wireMessage.payloadMessage.retained) storedMessage.payloadMessage.retained = true;
+                            if (prefix.indexOf("Sent:") === 0) {
+                                if (wireMessage.sequence === void 0) wireMessage.sequence = ++this._sequence;
+                                storedMessage.sequence = wireMessage.sequence;
+                            }
+                            break;
+                        default:
+                            throw Error(format(ERROR.INVALID_STORED_DATA, [
+                                prefix + this._localKey + wireMessage.messageIdentifier,
+                                storedMessage
+                            ]));
+                    }
+                    localStorage.setItem(prefix + this._localKey + wireMessage.messageIdentifier, JSON.stringify(storedMessage));
+                };
+                ClientImpl.prototype.restore = function(key) {
+                    var value = localStorage.getItem(key);
+                    var storedMessage = JSON.parse(value);
+                    var wireMessage = new WireMessage(storedMessage.type, storedMessage);
+                    switch(storedMessage.type){
+                        case MESSAGE_TYPE.PUBLISH:
+                            var hex = storedMessage.payloadMessage.payloadHex;
+                            var buffer = new ArrayBuffer(hex.length / 2);
+                            var byteStream = new Uint8Array(buffer);
+                            var i = 0;
+                            while(hex.length >= 2){
+                                var x = parseInt(hex.substring(0, 2), 16);
+                                hex = hex.substring(2, hex.length);
+                                byteStream[i++] = x;
+                            }
+                            var payloadMessage = new PahoMQTT.Message(byteStream);
+                            payloadMessage.qos = storedMessage.payloadMessage.qos;
+                            payloadMessage.destinationName = storedMessage.payloadMessage.destinationName;
+                            if (storedMessage.payloadMessage.duplicate) payloadMessage.duplicate = true;
+                            if (storedMessage.payloadMessage.retained) payloadMessage.retained = true;
+                            wireMessage.payloadMessage = payloadMessage;
+                            break;
+                        default:
+                            throw Error(format(ERROR.INVALID_STORED_DATA, [
+                                key,
+                                value
+                            ]));
+                    }
+                    if (key.indexOf("Sent:" + this._localKey) === 0) {
+                        wireMessage.payloadMessage.duplicate = true;
+                        this._sentMessages[wireMessage.messageIdentifier] = wireMessage;
+                    } else if (key.indexOf("Received:" + this._localKey) === 0) {
+                        this._receivedMessages[wireMessage.messageIdentifier] = wireMessage;
+                    }
+                };
+                ClientImpl.prototype._process_queue = function() {
+                    var message = null;
+                    while(message = this._msg_queue.pop()){
+                        this._socket_send(message);
+                        if (this._notify_msg_sent[message]) {
+                            this._notify_msg_sent[message]();
+                            delete this._notify_msg_sent[message];
+                        }
+                    }
+                };
+                ClientImpl.prototype._requires_ack = function(wireMessage) {
+                    var messageCount = Object.keys(this._sentMessages).length;
+                    if (messageCount > this.maxMessageIdentifier) throw Error("Too many messages:" + messageCount);
+                    while(this._sentMessages[this._message_identifier] !== void 0){
+                        this._message_identifier++;
+                    }
+                    wireMessage.messageIdentifier = this._message_identifier;
+                    this._sentMessages[wireMessage.messageIdentifier] = wireMessage;
+                    if (wireMessage.type === MESSAGE_TYPE.PUBLISH) {
+                        this.store("Sent:", wireMessage);
+                    }
+                    if (this._message_identifier === this.maxMessageIdentifier) {
+                        this._message_identifier = 1;
+                    }
+                };
+                ClientImpl.prototype._on_socket_open = function() {
+                    var wireMessage = new WireMessage(MESSAGE_TYPE.CONNECT, this.connectOptions);
+                    wireMessage.clientId = this.clientId;
+                    this._socket_send(wireMessage);
+                };
+                ClientImpl.prototype._on_socket_message = function(event) {
+                    this._trace("Client._on_socket_message", event.data);
+                    var messages = this._deframeMessages(event.data);
+                    for(var i = 0; i < messages.length; i += 1){
+                        this._handleMessage(messages[i]);
+                    }
+                };
+                ClientImpl.prototype._deframeMessages = function(data) {
+                    var byteArray = new Uint8Array(data);
+                    var messages = [];
+                    if (this.receiveBuffer) {
+                        var newData = new Uint8Array(this.receiveBuffer.length + byteArray.length);
+                        newData.set(this.receiveBuffer);
+                        newData.set(byteArray, this.receiveBuffer.length);
+                        byteArray = newData;
+                        delete this.receiveBuffer;
+                    }
+                    try {
+                        var offset = 0;
+                        while(offset < byteArray.length){
+                            var result = decodeMessage(byteArray, offset);
+                            var wireMessage = result[0];
+                            offset = result[1];
+                            if (wireMessage !== null) {
+                                messages.push(wireMessage);
+                            } else {
+                                break;
+                            }
+                        }
+                        if (offset < byteArray.length) {
+                            this.receiveBuffer = byteArray.subarray(offset);
+                        }
+                    } catch (error) {
+                        var errorStack = error.hasOwnProperty("stack") == "undefined" ? error.stack.toString() : "No Error Stack Available";
+                        this._disconnected(ERROR.INTERNAL_ERROR.code, format(ERROR.INTERNAL_ERROR, [
+                            error.message,
+                            errorStack
+                        ]));
+                        return;
+                    }
+                    return messages;
+                };
+                ClientImpl.prototype._handleMessage = function(wireMessage) {
+                    this._trace("Client._handleMessage", wireMessage);
+                    try {
+                        switch(wireMessage.type){
+                            case MESSAGE_TYPE.CONNACK:
+                                this._connectTimeout.cancel();
+                                if (this._reconnectTimeout) this._reconnectTimeout.cancel();
+                                if (this.connectOptions.cleanSession) {
+                                    for(var key in this._sentMessages){
+                                        var sentMessage = this._sentMessages[key];
+                                        localStorage.removeItem("Sent:" + this._localKey + sentMessage.messageIdentifier);
+                                    }
+                                    this._sentMessages = {};
+                                    for(var key in this._receivedMessages){
+                                        var receivedMessage = this._receivedMessages[key];
+                                        localStorage.removeItem("Received:" + this._localKey + receivedMessage.messageIdentifier);
+                                    }
+                                    this._receivedMessages = {};
+                                }
+                                if (wireMessage.returnCode === 0) {
+                                    this.connected = true;
+                                    if (this.connectOptions.uris) this.hostIndex = this.connectOptions.uris.length;
+                                } else {
+                                    this._disconnected(ERROR.CONNACK_RETURNCODE.code, format(ERROR.CONNACK_RETURNCODE, [
+                                        wireMessage.returnCode,
+                                        CONNACK_RC[wireMessage.returnCode]
+                                    ]));
+                                    break;
+                                }
+                                var sequencedMessages = [];
+                                for(var msgId in this._sentMessages){
+                                    if (this._sentMessages.hasOwnProperty(msgId)) sequencedMessages.push(this._sentMessages[msgId]);
+                                }
+                                if (this._buffered_msg_queue.length > 0) {
+                                    var msg = null;
+                                    while(msg = this._buffered_msg_queue.pop()){
+                                        sequencedMessages.push(msg);
+                                        if (this.onMessageDelivered) this._notify_msg_sent[msg] = this.onMessageDelivered(msg.payloadMessage);
+                                    }
+                                }
+                                var sequencedMessages = sequencedMessages.sort(function(a, b) {
+                                    return a.sequence - b.sequence;
+                                });
+                                for(var i = 0, len = sequencedMessages.length; i < len; i++){
+                                    var sentMessage = sequencedMessages[i];
+                                    if (sentMessage.type == MESSAGE_TYPE.PUBLISH && sentMessage.pubRecReceived) {
+                                        var pubRelMessage = new WireMessage(MESSAGE_TYPE.PUBREL, {
+                                            messageIdentifier: sentMessage.messageIdentifier
+                                        });
+                                        this._schedule_message(pubRelMessage);
+                                    } else {
+                                        this._schedule_message(sentMessage);
+                                    }
+                                }
+                                if (this.connectOptions.onSuccess) {
+                                    this.connectOptions.onSuccess({
+                                        invocationContext: this.connectOptions.invocationContext
+                                    });
+                                }
+                                var reconnected = false;
+                                if (this._reconnecting) {
+                                    reconnected = true;
+                                    this._reconnectInterval = 1;
+                                    this._reconnecting = false;
+                                }
+                                this._connected(reconnected, this._wsuri);
+                                this._process_queue();
+                                break;
+                            case MESSAGE_TYPE.PUBLISH:
+                                this._receivePublish(wireMessage);
+                                break;
+                            case MESSAGE_TYPE.PUBACK:
+                                var sentMessage = this._sentMessages[wireMessage.messageIdentifier];
+                                if (sentMessage) {
+                                    delete this._sentMessages[wireMessage.messageIdentifier];
+                                    localStorage.removeItem("Sent:" + this._localKey + wireMessage.messageIdentifier);
+                                    if (this.onMessageDelivered) this.onMessageDelivered(sentMessage.payloadMessage);
+                                }
+                                break;
+                            case MESSAGE_TYPE.PUBREC:
+                                var sentMessage = this._sentMessages[wireMessage.messageIdentifier];
+                                if (sentMessage) {
+                                    sentMessage.pubRecReceived = true;
+                                    var pubRelMessage = new WireMessage(MESSAGE_TYPE.PUBREL, {
+                                        messageIdentifier: wireMessage.messageIdentifier
+                                    });
+                                    this.store("Sent:", sentMessage);
+                                    this._schedule_message(pubRelMessage);
+                                }
+                                break;
+                            case MESSAGE_TYPE.PUBREL:
+                                var receivedMessage = this._receivedMessages[wireMessage.messageIdentifier];
+                                localStorage.removeItem("Received:" + this._localKey + wireMessage.messageIdentifier);
+                                if (receivedMessage) {
+                                    this._receiveMessage(receivedMessage);
+                                    delete this._receivedMessages[wireMessage.messageIdentifier];
+                                }
+                                var pubCompMessage = new WireMessage(MESSAGE_TYPE.PUBCOMP, {
+                                    messageIdentifier: wireMessage.messageIdentifier
+                                });
+                                this._schedule_message(pubCompMessage);
+                                break;
+                            case MESSAGE_TYPE.PUBCOMP:
+                                var sentMessage = this._sentMessages[wireMessage.messageIdentifier];
+                                delete this._sentMessages[wireMessage.messageIdentifier];
+                                localStorage.removeItem("Sent:" + this._localKey + wireMessage.messageIdentifier);
+                                if (this.onMessageDelivered) this.onMessageDelivered(sentMessage.payloadMessage);
+                                break;
+                            case MESSAGE_TYPE.SUBACK:
+                                var sentMessage = this._sentMessages[wireMessage.messageIdentifier];
+                                if (sentMessage) {
+                                    if (sentMessage.timeOut) sentMessage.timeOut.cancel();
+                                    if (wireMessage.returnCode[0] === 128) {
+                                        if (sentMessage.onFailure) {
+                                            sentMessage.onFailure(wireMessage.returnCode);
+                                        }
+                                    } else if (sentMessage.onSuccess) {
+                                        sentMessage.onSuccess(wireMessage.returnCode);
+                                    }
+                                    delete this._sentMessages[wireMessage.messageIdentifier];
+                                }
+                                break;
+                            case MESSAGE_TYPE.UNSUBACK:
+                                var sentMessage = this._sentMessages[wireMessage.messageIdentifier];
+                                if (sentMessage) {
+                                    if (sentMessage.timeOut) sentMessage.timeOut.cancel();
+                                    if (sentMessage.callback) {
+                                        sentMessage.callback();
+                                    }
+                                    delete this._sentMessages[wireMessage.messageIdentifier];
+                                }
+                                break;
+                            case MESSAGE_TYPE.PINGRESP:
+                                this.sendPinger.reset();
+                                break;
+                            case MESSAGE_TYPE.DISCONNECT:
+                                this._disconnected(ERROR.INVALID_MQTT_MESSAGE_TYPE.code, format(ERROR.INVALID_MQTT_MESSAGE_TYPE, [
+                                    wireMessage.type
+                                ]));
+                                break;
+                            default:
+                                this._disconnected(ERROR.INVALID_MQTT_MESSAGE_TYPE.code, format(ERROR.INVALID_MQTT_MESSAGE_TYPE, [
+                                    wireMessage.type
+                                ]));
+                        }
+                    } catch (error) {
+                        var errorStack = error.hasOwnProperty("stack") == "undefined" ? error.stack.toString() : "No Error Stack Available";
+                        this._disconnected(ERROR.INTERNAL_ERROR.code, format(ERROR.INTERNAL_ERROR, [
+                            error.message,
+                            errorStack
+                        ]));
+                        return;
+                    }
+                };
+                ClientImpl.prototype._on_socket_error = function(error) {
+                    if (!this._reconnecting) {
+                        this._disconnected(ERROR.SOCKET_ERROR.code, format(ERROR.SOCKET_ERROR, [
+                            error.data
+                        ]));
+                    }
+                };
+                ClientImpl.prototype._on_socket_close = function() {
+                    if (!this._reconnecting) {
+                        this._disconnected(ERROR.SOCKET_CLOSE.code, format(ERROR.SOCKET_CLOSE));
+                    }
+                };
+                ClientImpl.prototype._socket_send = function(wireMessage) {
+                    if (wireMessage.type == 1) {
+                        var wireMessageMasked = this._traceMask(wireMessage, "password");
+                        this._trace("Client._socket_send", wireMessageMasked);
+                    } else this._trace("Client._socket_send", wireMessage);
+                    this.socket.send(wireMessage.encode());
+                    this.sendPinger.reset();
+                };
+                ClientImpl.prototype._receivePublish = function(wireMessage) {
+                    switch(wireMessage.payloadMessage.qos){
+                        case "undefined":
+                        case 0:
+                            this._receiveMessage(wireMessage);
+                            break;
+                        case 1:
+                            var pubAckMessage = new WireMessage(MESSAGE_TYPE.PUBACK, {
+                                messageIdentifier: wireMessage.messageIdentifier
+                            });
+                            this._schedule_message(pubAckMessage);
+                            this._receiveMessage(wireMessage);
+                            break;
+                        case 2:
+                            this._receivedMessages[wireMessage.messageIdentifier] = wireMessage;
+                            this.store("Received:", wireMessage);
+                            var pubRecMessage = new WireMessage(MESSAGE_TYPE.PUBREC, {
+                                messageIdentifier: wireMessage.messageIdentifier
+                            });
+                            this._schedule_message(pubRecMessage);
+                            break;
+                        default:
+                            throw Error("Invaild qos=" + wireMessage.payloadMessage.qos);
+                    }
+                };
+                ClientImpl.prototype._receiveMessage = function(wireMessage) {
+                    if (this.onMessageArrived) {
+                        this.onMessageArrived(wireMessage.payloadMessage);
+                    }
+                };
+                ClientImpl.prototype._connected = function(reconnect, uri) {
+                    if (this.onConnected) this.onConnected(reconnect, uri);
+                };
+                ClientImpl.prototype._reconnect = function() {
+                    this._trace("Client._reconnect");
+                    if (!this.connected) {
+                        this._reconnecting = true;
+                        this.sendPinger.cancel();
+                        this.receivePinger.cancel();
+                        if (this._reconnectInterval < 128) this._reconnectInterval = this._reconnectInterval * 2;
+                        if (this.connectOptions.uris) {
+                            this.hostIndex = 0;
+                            this._doConnect(this.connectOptions.uris[0]);
+                        } else {
+                            this._doConnect(this.uri);
+                        }
+                    }
+                };
+                ClientImpl.prototype._disconnected = function(errorCode, errorText) {
+                    this._trace("Client._disconnected", errorCode, errorText);
+                    if (errorCode !== void 0 && this._reconnecting) {
+                        this._reconnectTimeout = new Timeout(this, this._reconnectInterval, this._reconnect);
+                        return;
+                    }
+                    this.sendPinger.cancel();
+                    this.receivePinger.cancel();
+                    if (this._connectTimeout) {
+                        this._connectTimeout.cancel();
+                        this._connectTimeout = null;
+                    }
+                    this._msg_queue = [];
+                    this._buffered_msg_queue = [];
+                    this._notify_msg_sent = {};
+                    if (this.socket) {
+                        this.socket.onopen = null;
+                        this.socket.onmessage = null;
+                        this.socket.onerror = null;
+                        this.socket.onclose = null;
+                        if (this.socket.readyState === 1) this.socket.close();
+                        delete this.socket;
+                    }
+                    if (this.connectOptions.uris && this.hostIndex < this.connectOptions.uris.length - 1) {
+                        this.hostIndex++;
+                        this._doConnect(this.connectOptions.uris[this.hostIndex]);
+                    } else {
+                        if (errorCode === void 0) {
+                            errorCode = ERROR.OK.code;
+                            errorText = format(ERROR.OK);
+                        }
+                        if (this.connected) {
+                            this.connected = false;
+                            if (this.onConnectionLost) {
+                                this.onConnectionLost({
+                                    errorCode: errorCode,
+                                    errorMessage: errorText,
+                                    reconnect: this.connectOptions.reconnect,
+                                    uri: this._wsuri
+                                });
+                            }
+                            if (errorCode !== ERROR.OK.code && this.connectOptions.reconnect) {
+                                this._reconnectInterval = 1;
+                                this._reconnect();
+                                return;
+                            }
+                        } else {
+                            if (this.connectOptions.mqttVersion === 4 && this.connectOptions.mqttVersionExplicit === false) {
+                                this._trace("Failed to connect V4, dropping back to V3");
+                                this.connectOptions.mqttVersion = 3;
+                                if (this.connectOptions.uris) {
+                                    this.hostIndex = 0;
+                                    this._doConnect(this.connectOptions.uris[0]);
+                                } else {
+                                    this._doConnect(this.uri);
+                                }
+                            } else if (this.connectOptions.onFailure) {
+                                this.connectOptions.onFailure({
+                                    invocationContext: this.connectOptions.invocationContext,
+                                    errorCode: errorCode,
+                                    errorMessage: errorText
+                                });
+                            }
+                        }
+                    }
+                };
+                ClientImpl.prototype._trace = function() {
+                    if (this.traceFunction) {
+                        var args = Array.prototype.slice.call(arguments);
+                        for(var i in args){
+                            if (typeof args[i] !== "undefined") args.splice(i, 1, JSON.stringify(args[i]));
+                        }
+                        var record = args.join("");
+                        this.traceFunction({
+                            severity: "Debug",
+                            message: record
+                        });
+                    }
+                    if (this._traceBuffer !== null) {
+                        for(var i = 0, max = arguments.length; i < max; i++){
+                            if (this._traceBuffer.length == this._MAX_TRACE_ENTRIES) {
+                                this._traceBuffer.shift();
+                            }
+                            if (i === 0) this._traceBuffer.push(arguments[i]);
+                            else if (typeof arguments[i] === "undefined") this._traceBuffer.push(arguments[i]);
+                            else this._traceBuffer.push("  " + JSON.stringify(arguments[i]));
+                        }
+                    }
+                };
+                ClientImpl.prototype._traceMask = function(traceObject, masked) {
+                    var traceObjectMasked = {};
+                    for(var attr in traceObject){
+                        if (traceObject.hasOwnProperty(attr)) {
+                            if (attr == masked) traceObjectMasked[attr] = "******";
+                            else traceObjectMasked[attr] = traceObject[attr];
+                        }
+                    }
+                    return traceObjectMasked;
+                };
+                var Client2 = function Client2(host, port, path, clientId) {
+                    var uri;
+                    if (typeof host !== "string") throw new Error(format(ERROR.INVALID_TYPE, [
+                        typeof host === "undefined" ? "undefined" : _type_of(host),
+                        "host"
+                    ]));
+                    if (arguments.length == 2) {
+                        clientId = port;
+                        uri = host;
+                        var match = uri.match(/^(wss?):\/\/((\[(.+)\])|([^\/]+?))(:(\d+))?(\/.*)$/);
+                        if (match) {
+                            host = match[4] || match[2];
+                            port = parseInt(match[7]);
+                            path = match[8];
+                        } else {
+                            throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                host,
+                                "host"
+                            ]));
+                        }
+                    } else {
+                        if (arguments.length == 3) {
+                            clientId = path;
+                            path = "/mqtt";
+                        }
+                        if (typeof port !== "number" || port < 0) throw new Error(format(ERROR.INVALID_TYPE, [
+                            typeof port === "undefined" ? "undefined" : _type_of(port),
+                            "port"
+                        ]));
+                        if (typeof path !== "string") throw new Error(format(ERROR.INVALID_TYPE, [
+                            typeof path === "undefined" ? "undefined" : _type_of(path),
+                            "path"
+                        ]));
+                        var ipv6AddSBracket = host.indexOf(":") !== -1 && host.slice(0, 1) !== "[" && host.slice(-1) !== "]";
+                        uri = "ws://" + (ipv6AddSBracket ? "[" + host + "]" : host) + ":" + port + path;
+                    }
+                    var clientIdLength = 0;
+                    for(var i = 0; i < clientId.length; i++){
+                        var charCode = clientId.charCodeAt(i);
+                        if (55296 <= charCode && charCode <= 56319) {
+                            i++;
+                        }
+                        clientIdLength++;
+                    }
+                    if (typeof clientId !== "string" || clientIdLength > 65535) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                        clientId,
+                        "clientId"
+                    ]));
+                    var client = new ClientImpl(uri, host, port, path, clientId);
+                    Object.defineProperties(this, {
+                        "host": {
+                            get: function get() {
+                                return host;
+                            },
+                            set: function set() {
+                                throw new Error(format(ERROR.UNSUPPORTED_OPERATION));
+                            }
+                        },
+                        "port": {
+                            get: function get() {
+                                return port;
+                            },
+                            set: function set() {
+                                throw new Error(format(ERROR.UNSUPPORTED_OPERATION));
+                            }
+                        },
+                        "path": {
+                            get: function get() {
+                                return path;
+                            },
+                            set: function set() {
+                                throw new Error(format(ERROR.UNSUPPORTED_OPERATION));
+                            }
+                        },
+                        "uri": {
+                            get: function get() {
+                                return uri;
+                            },
+                            set: function set() {
+                                throw new Error(format(ERROR.UNSUPPORTED_OPERATION));
+                            }
+                        },
+                        "clientId": {
+                            get: function get() {
+                                return client.clientId;
+                            },
+                            set: function set() {
+                                throw new Error(format(ERROR.UNSUPPORTED_OPERATION));
+                            }
+                        },
+                        "onConnected": {
+                            get: function get() {
+                                return client.onConnected;
+                            },
+                            set: function set(newOnConnected) {
+                                if (typeof newOnConnected === "function") client.onConnected = newOnConnected;
+                                else throw new Error(format(ERROR.INVALID_TYPE, [
+                                    typeof newOnConnected === "undefined" ? "undefined" : _type_of(newOnConnected),
+                                    "onConnected"
+                                ]));
+                            }
+                        },
+                        "disconnectedPublishing": {
+                            get: function get() {
+                                return client.disconnectedPublishing;
+                            },
+                            set: function set(newDisconnectedPublishing) {
+                                client.disconnectedPublishing = newDisconnectedPublishing;
+                            }
+                        },
+                        "disconnectedBufferSize": {
+                            get: function get() {
+                                return client.disconnectedBufferSize;
+                            },
+                            set: function set(newDisconnectedBufferSize) {
+                                client.disconnectedBufferSize = newDisconnectedBufferSize;
+                            }
+                        },
+                        "onConnectionLost": {
+                            get: function get() {
+                                return client.onConnectionLost;
+                            },
+                            set: function set(newOnConnectionLost) {
+                                if (typeof newOnConnectionLost === "function") client.onConnectionLost = newOnConnectionLost;
+                                else throw new Error(format(ERROR.INVALID_TYPE, [
+                                    typeof newOnConnectionLost === "undefined" ? "undefined" : _type_of(newOnConnectionLost),
+                                    "onConnectionLost"
+                                ]));
+                            }
+                        },
+                        "onMessageDelivered": {
+                            get: function get() {
+                                return client.onMessageDelivered;
+                            },
+                            set: function set(newOnMessageDelivered) {
+                                if (typeof newOnMessageDelivered === "function") client.onMessageDelivered = newOnMessageDelivered;
+                                else throw new Error(format(ERROR.INVALID_TYPE, [
+                                    typeof newOnMessageDelivered === "undefined" ? "undefined" : _type_of(newOnMessageDelivered),
+                                    "onMessageDelivered"
+                                ]));
+                            }
+                        },
+                        "onMessageArrived": {
+                            get: function get() {
+                                return client.onMessageArrived;
+                            },
+                            set: function set(newOnMessageArrived) {
+                                if (typeof newOnMessageArrived === "function") client.onMessageArrived = newOnMessageArrived;
+                                else throw new Error(format(ERROR.INVALID_TYPE, [
+                                    typeof newOnMessageArrived === "undefined" ? "undefined" : _type_of(newOnMessageArrived),
+                                    "onMessageArrived"
+                                ]));
+                            }
+                        },
+                        "trace": {
+                            get: function get() {
+                                return client.traceFunction;
+                            },
+                            set: function set(trace) {
+                                if (typeof trace === "function") {
+                                    client.traceFunction = trace;
+                                } else {
+                                    throw new Error(format(ERROR.INVALID_TYPE, [
+                                        typeof trace === "undefined" ? "undefined" : _type_of(trace),
+                                        "onTrace"
+                                    ]));
+                                }
+                            }
+                        }
+                    });
+                    this.connect = function(connectOptions) {
+                        connectOptions = connectOptions || {};
+                        validate(connectOptions, {
+                            timeout: "number",
+                            userName: "string",
+                            password: "string",
+                            willMessage: "object",
+                            keepAliveInterval: "number",
+                            cleanSession: "boolean",
+                            useSSL: "boolean",
+                            invocationContext: "object",
+                            onSuccess: "function",
+                            onFailure: "function",
+                            hosts: "object",
+                            ports: "object",
+                            reconnect: "boolean",
+                            mqttVersion: "number",
+                            mqttVersionExplicit: "boolean",
+                            uris: "object"
+                        });
+                        if (connectOptions.keepAliveInterval === void 0) connectOptions.keepAliveInterval = 60;
+                        if (connectOptions.mqttVersion > 4 || connectOptions.mqttVersion < 3) {
+                            throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                connectOptions.mqttVersion,
+                                "connectOptions.mqttVersion"
+                            ]));
+                        }
+                        if (connectOptions.mqttVersion === void 0) {
+                            connectOptions.mqttVersionExplicit = false;
+                            connectOptions.mqttVersion = 4;
+                        } else {
+                            connectOptions.mqttVersionExplicit = true;
+                        }
+                        if (connectOptions.password !== void 0 && connectOptions.userName === void 0) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                            connectOptions.password,
+                            "connectOptions.password"
+                        ]));
+                        if (connectOptions.willMessage) {
+                            if (!_instanceof(connectOptions.willMessage, Message)) throw new Error(format(ERROR.INVALID_TYPE, [
+                                connectOptions.willMessage,
+                                "connectOptions.willMessage"
+                            ]));
+                            connectOptions.willMessage.stringPayload = null;
+                            if (typeof connectOptions.willMessage.destinationName === "undefined") throw new Error(format(ERROR.INVALID_TYPE, [
+                                _type_of(connectOptions.willMessage.destinationName),
+                                "connectOptions.willMessage.destinationName"
+                            ]));
+                        }
+                        if (typeof connectOptions.cleanSession === "undefined") connectOptions.cleanSession = true;
+                        if (connectOptions.hosts) {
+                            if (!_instanceof(connectOptions.hosts, Array)) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                connectOptions.hosts,
+                                "connectOptions.hosts"
+                            ]));
+                            if (connectOptions.hosts.length < 1) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                connectOptions.hosts,
+                                "connectOptions.hosts"
+                            ]));
+                            var usingURIs = false;
+                            for(var i2 = 0; i2 < connectOptions.hosts.length; i2++){
+                                if (typeof connectOptions.hosts[i2] !== "string") throw new Error(format(ERROR.INVALID_TYPE, [
+                                    _type_of(connectOptions.hosts[i2]),
+                                    "connectOptions.hosts[" + i2 + "]"
+                                ]));
+                                if (/^(wss?):\/\/((\[(.+)\])|([^\/]+?))(:(\d+))?(\/.*)$/.test(connectOptions.hosts[i2])) {
+                                    if (i2 === 0) {
+                                        usingURIs = true;
+                                    } else if (!usingURIs) {
+                                        throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                            connectOptions.hosts[i2],
+                                            "connectOptions.hosts[" + i2 + "]"
+                                        ]));
+                                    }
+                                } else if (usingURIs) {
+                                    throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                        connectOptions.hosts[i2],
+                                        "connectOptions.hosts[" + i2 + "]"
+                                    ]));
+                                }
+                            }
+                            if (!usingURIs) {
+                                if (!connectOptions.ports) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                    connectOptions.ports,
+                                    "connectOptions.ports"
+                                ]));
+                                if (!_instanceof(connectOptions.ports, Array)) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                    connectOptions.ports,
+                                    "connectOptions.ports"
+                                ]));
+                                if (connectOptions.hosts.length !== connectOptions.ports.length) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                    connectOptions.ports,
+                                    "connectOptions.ports"
+                                ]));
+                                connectOptions.uris = [];
+                                for(var i2 = 0; i2 < connectOptions.hosts.length; i2++){
+                                    if (typeof connectOptions.ports[i2] !== "number" || connectOptions.ports[i2] < 0) throw new Error(format(ERROR.INVALID_TYPE, [
+                                        _type_of(connectOptions.ports[i2]),
+                                        "connectOptions.ports[" + i2 + "]"
+                                    ]));
+                                    var host2 = connectOptions.hosts[i2];
+                                    var port2 = connectOptions.ports[i2];
+                                    var ipv6 = host2.indexOf(":") !== -1;
+                                    uri = "ws://" + (ipv6 ? "[" + host2 + "]" : host2) + ":" + port2 + path;
+                                    connectOptions.uris.push(uri);
+                                }
+                            } else {
+                                connectOptions.uris = connectOptions.hosts;
+                            }
+                        }
+                        client.connect(connectOptions);
+                    };
+                    this.subscribe = function(filter3, subscribeOptions) {
+                        if (typeof filter3 !== "string") throw new Error("Invalid argument:" + filter3);
+                        subscribeOptions = subscribeOptions || {};
+                        validate(subscribeOptions, {
+                            qos: "number",
+                            invocationContext: "object",
+                            onSuccess: "function",
+                            onFailure: "function",
+                            timeout: "number"
+                        });
+                        if (subscribeOptions.timeout && !subscribeOptions.onFailure) throw new Error("subscribeOptions.timeout specified with no onFailure callback.");
+                        if (typeof subscribeOptions.qos !== "undefined" && !(subscribeOptions.qos === 0 || subscribeOptions.qos === 1 || subscribeOptions.qos === 2)) throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                            subscribeOptions.qos,
+                            "subscribeOptions.qos"
+                        ]));
+                        client.subscribe(filter3, subscribeOptions);
+                    };
+                    this.unsubscribe = function(filter3, unsubscribeOptions) {
+                        if (typeof filter3 !== "string") throw new Error("Invalid argument:" + filter3);
+                        unsubscribeOptions = unsubscribeOptions || {};
+                        validate(unsubscribeOptions, {
+                            invocationContext: "object",
+                            onSuccess: "function",
+                            onFailure: "function",
+                            timeout: "number"
+                        });
+                        if (unsubscribeOptions.timeout && !unsubscribeOptions.onFailure) throw new Error("unsubscribeOptions.timeout specified with no onFailure callback.");
+                        client.unsubscribe(filter3, unsubscribeOptions);
+                    };
+                    this.send = function(topic, payload, qos, retained) {
+                        var message;
+                        if (arguments.length === 0) {
+                            throw new Error("Invalid argument.length");
+                        } else if (arguments.length == 1) {
+                            if (!_instanceof(topic, Message) && typeof topic !== "string") throw new Error("Invalid argument:" + (typeof topic === "undefined" ? "undefined" : _type_of(topic)));
+                            message = topic;
+                            if (typeof message.destinationName === "undefined") throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                message.destinationName,
+                                "Message.destinationName"
+                            ]));
+                            client.send(message);
+                        } else {
+                            message = new Message(payload);
+                            message.destinationName = topic;
+                            if (arguments.length >= 3) message.qos = qos;
+                            if (arguments.length >= 4) message.retained = retained;
+                            client.send(message);
+                        }
+                    };
+                    this.publish = function(topic, payload, qos, retained) {
+                        var message;
+                        if (arguments.length === 0) {
+                            throw new Error("Invalid argument.length");
+                        } else if (arguments.length == 1) {
+                            if (!_instanceof(topic, Message) && typeof topic !== "string") throw new Error("Invalid argument:" + (typeof topic === "undefined" ? "undefined" : _type_of(topic)));
+                            message = topic;
+                            if (typeof message.destinationName === "undefined") throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                message.destinationName,
+                                "Message.destinationName"
+                            ]));
+                            client.send(message);
+                        } else {
+                            message = new Message(payload);
+                            message.destinationName = topic;
+                            if (arguments.length >= 3) message.qos = qos;
+                            if (arguments.length >= 4) message.retained = retained;
+                            client.send(message);
+                        }
+                    };
+                    this.disconnect = function() {
+                        client.disconnect();
+                    };
+                    this.getTraceLog = function() {
+                        return client.getTraceLog();
+                    };
+                    this.startTrace = function() {
+                        client.startTrace();
+                    };
+                    this.stopTrace = function() {
+                        client.stopTrace();
+                    };
+                    this.isConnected = function() {
+                        return client.connected;
+                    };
+                };
+                var Message = function Message(newPayload) {
+                    var payload;
+                    if (typeof newPayload === "string" || _instanceof(newPayload, ArrayBuffer) || ArrayBuffer.isView(newPayload) && !_instanceof(newPayload, DataView)) {
+                        payload = newPayload;
+                    } else {
+                        throw format(ERROR.INVALID_ARGUMENT, [
+                            newPayload,
+                            "newPayload"
+                        ]);
+                    }
+                    var destinationName;
+                    var qos = 0;
+                    var retained = false;
+                    var duplicate = false;
+                    Object.defineProperties(this, {
+                        "payloadString": {
+                            enumerable: true,
+                            get: function get() {
+                                if (typeof payload === "string") return payload;
+                                else return parseUTF8(payload, 0, payload.length);
+                            }
+                        },
+                        "payloadBytes": {
+                            enumerable: true,
+                            get: function get() {
+                                if (typeof payload === "string") {
+                                    var buffer = new ArrayBuffer(UTF8Length(payload));
+                                    var byteStream = new Uint8Array(buffer);
+                                    stringToUTF8(payload, byteStream, 0);
+                                    return byteStream;
+                                } else {
+                                    return payload;
+                                }
+                            }
+                        },
+                        "destinationName": {
+                            enumerable: true,
+                            get: function get() {
+                                return destinationName;
+                            },
+                            set: function set(newDestinationName) {
+                                if (typeof newDestinationName === "string") destinationName = newDestinationName;
+                                else throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                    newDestinationName,
+                                    "newDestinationName"
+                                ]));
+                            }
+                        },
+                        "qos": {
+                            enumerable: true,
+                            get: function get() {
+                                return qos;
+                            },
+                            set: function set(newQos) {
+                                if (newQos === 0 || newQos === 1 || newQos === 2) qos = newQos;
+                                else throw new Error("Invalid argument:" + newQos);
+                            }
+                        },
+                        "retained": {
+                            enumerable: true,
+                            get: function get() {
+                                return retained;
+                            },
+                            set: function set(newRetained) {
+                                if (typeof newRetained === "boolean") retained = newRetained;
+                                else throw new Error(format(ERROR.INVALID_ARGUMENT, [
+                                    newRetained,
+                                    "newRetained"
+                                ]));
+                            }
+                        },
+                        "topic": {
+                            enumerable: true,
+                            get: function get() {
+                                return destinationName;
+                            },
+                            set: function set(newTopic) {
+                                destinationName = newTopic;
+                            }
+                        },
+                        "duplicate": {
+                            enumerable: true,
+                            get: function get() {
+                                return duplicate;
+                            },
+                            set: function set(newDuplicate) {
+                                duplicate = newDuplicate;
+                            }
+                        }
+                    });
+                };
+                return {
+                    Client: Client2,
+                    Message: Message
+                };
+            }(typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
+            return PahoMQTT;
+        });
+    }
+});
+// src/subscription-handshake-link.ts
+import { ApolloLink, Observable } from "@apollo/client/core";
+import { CombinedGraphQLErrors } from "@apollo/client/errors";
+import { filter } from "rxjs/operators";
+// src/utils/logger.ts
+import debug from "debug";
+var debugLogger = debug("aws-appsync");
+var extend = function extend1() {
+    var category = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+    var newCategory = category ? _to_consumable_array(this.namespace.split(":")).concat([
+        category
+    ]).join(":") : this.namespace;
+    var result = debug(newCategory);
+    result.extend = extend.bind(result);
+    return result;
+};
+debugLogger.extend = extend.bind(debugLogger);
+var logger_default = debugLogger;
+// src/subscription-handshake-link.ts
+var Paho = __toESM(require_paho_mqtt());
+import { getMainDefinition } from "@apollo/client/utilities";
+var logger = logger_default.extend("subscriptions");
+var mqttLogger = logger.extend("mqtt");
+var CONTROL_EVENTS_KEY = "@@controlEvents";
+var SubscriptionHandshakeLink = /*#__PURE__*/ function(ApolloLink) {
+    "use strict";
+    _inherits(SubscriptionHandshakeLink, ApolloLink);
+    function SubscriptionHandshakeLink(subsInfoContextKey) {
+        _class_call_check(this, SubscriptionHandshakeLink);
+        var _this;
+        _this = _call_super(this, SubscriptionHandshakeLink);
+        _this.topicObservers = /* @__PURE__ */ new Map();
+        _this.clientObservers = /* @__PURE__ */ new Map();
+        _this.onMessage = function(topic, message, selectionNames) {
+            var parsedMessage = JSON.parse(message);
+            var observers = _this.topicObservers.get(topic);
+            var data = selectionNames.reduce(function(acc, name) {
+                return acc[name] = acc[name] || null, acc;
+            }, parsedMessage.data || {});
+            logger("Message received", {
+                data: data,
+                topic: topic,
+                observers: observers
+            });
+            observers.forEach(function(observer) {
+                try {
+                    observer.next(_object_spread({}, parsedMessage, {
+                        data: data
+                    }));
+                } catch (err) {
+                    logger(err);
+                }
+            });
+        };
+        _this.subsInfoContextKey = subsInfoContextKey;
+        return _this;
+    }
+    _create_class(SubscriptionHandshakeLink, [
+        _define_property({
+            key: "request"
+        }, "value", function request(operation) {
+            var _this = this;
+            var _operation_getContext = operation.getContext(), subsInfo = _operation_getContext[this.subsInfoContextKey], tmp = _operation_getContext.controlMessages, _ref = tmp === void 0 ? _define_property({}, CONTROL_EVENTS_KEY, void 0) : tmp, controlEvents = _ref[CONTROL_EVENTS_KEY];
+            var tmp1 = subsInfo.extensions, _ref1 = tmp1 === void 0 ? {
+                subscription: {
+                    newSubscriptions: {},
+                    mqttConnections: []
+                }
+            } : tmp1, _ref_subscription = _ref1.subscription, newSubscriptions = _ref_subscription.newSubscriptions, mqttConnections = _ref_subscription.mqttConnections, _subsInfo_errors = subsInfo.errors, errors = _subsInfo_errors === void 0 ? [] : _subsInfo_errors;
+            if (errors && errors.length) {
+                return new Observable(function(observer) {
+                    observer.error(new CombinedGraphQLErrors({
+                        errors: errors,
+                        data: null
+                    }));
+                    return function() {};
+                });
+            }
+            var newSubscriptionTopics = Object.keys(newSubscriptions).map(function(subKey) {
+                return newSubscriptions[subKey].topic;
+            });
+            var existingTopicsWithObserver = new Set(newSubscriptionTopics.filter(function(t) {
+                return _this.topicObservers.has(t);
+            }));
+            var newTopics = new Set(newSubscriptionTopics.filter(function(t) {
+                return !existingTopicsWithObserver.has(t);
+            }));
+            return new Observable(function(observer) {
+                existingTopicsWithObserver.forEach(function(t) {
+                    _this.topicObservers.get(t).add(observer);
+                    var anObserver = Array.from(_this.topicObservers.get(t)).find(function() {
+                        return true;
+                    });
+                    var _Array_from_find = _sliced_to_array(Array.from(_this.clientObservers).find(function(param) {
+                        var _param = _sliced_to_array(param, 2), observers = _param[1].observers;
+                        return observers.has(anObserver);
+                    }), 1), clientId = _Array_from_find[0];
+                    _this.clientObservers.get(clientId).observers.add(observer);
+                });
+                var newTopicsConnectionInfo = mqttConnections.filter(function(c) {
+                    return c.topics.some(function(t) {
+                        return newTopics.has(t);
+                    });
+                }).map(function(_param) {
+                    var topics = _param.topics, rest = _object_without_properties(_param, [
+                        "topics"
+                    ]);
+                    return _object_spread_props(_object_spread({}, rest), {
+                        topics: topics.filter(function(t) {
+                            return newTopics.has(t);
+                        })
+                    });
+                });
+                _this.connectNewClients(newTopicsConnectionInfo, observer, operation);
+                return function() {
+                    var clientsForCurrentObserver = Array.from(_this.clientObservers).filter(function(param) {
+                        var _param = _sliced_to_array(param, 2), observers = _param[1].observers;
+                        return observers.has(observer);
+                    });
+                    clientsForCurrentObserver.forEach(function(param) {
+                        var _param = _sliced_to_array(param, 1), clientId = _param[0];
+                        return _this.clientObservers.get(clientId).observers.delete(observer);
+                    });
+                    _this.clientObservers.forEach(function(param) {
+                        var observers = param.observers, client = param.client;
+                        if (observers.size === 0) {
+                            if (client.isConnected()) {
+                                client.disconnect();
+                            }
+                            _this.clientObservers.delete(client.clientId);
+                        }
+                    });
+                    _this.clientObservers = new Map(Array.from(_this.clientObservers).filter(function(param) {
+                        var _param = _sliced_to_array(param, 2), observers = _param[1].observers;
+                        return observers.size > 0;
+                    }));
+                    _this.topicObservers.forEach(function(observers) {
+                        return observers.delete(observer);
+                    });
+                    _this.topicObservers = new Map(Array.from(_this.topicObservers).filter(function(param) {
+                        var _param = _sliced_to_array(param, 2), observers = _param[1];
+                        return observers.size > 0;
+                    }));
+                };
+            }).pipe(filter(function(data) {
+                var tmp = data.extensions, _ref = tmp === void 0 ? {} : tmp, _ref_controlMsgType = _ref.controlMsgType, controlMsgType = _ref_controlMsgType === void 0 ? void 0 : _ref_controlMsgType;
+                var isControlMsg = typeof controlMsgType !== "undefined";
+                return controlEvents === true || !isControlMsg;
+            }));
+        }),
+        {
+            key: "connectNewClients",
+            value: function connectNewClients(connectionInfo, observer, operation) {
+                return _async_to_generator(function() {
+                    var _this, query, selectionNames, result, data;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        query = operation.query;
+                        selectionNames = getMainDefinition(query).selectionSet.selections.map(function(param) {
+                            var value = param.name.value;
+                            return value;
+                        });
+                        result = Promise.all(connectionInfo.map(function(c) {
+                            return _this.connectNewClient(c, observer, selectionNames);
+                        }));
+                        data = selectionNames.reduce(function(acc, name) {
+                            return acc[name] = acc[name] || null, acc;
+                        }, {});
+                        observer.next({
+                            data: data,
+                            extensions: {
+                                controlMsgType: "CONNECTED",
+                                controlMsgInfo: {
+                                    connectionInfo: connectionInfo
+                                }
+                            }
+                        });
+                        return [
+                            2,
+                            result
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "connectNewClient",
+            value: function connectNewClient(connectionInfo, observer, selectionNames) {
+                return _async_to_generator(function() {
+                    var _this, clientId, url2, topics, client;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                clientId = connectionInfo.client, url2 = connectionInfo.url, topics = connectionInfo.topics;
+                                client = new Paho.Client(url2, clientId);
+                                client.trace = mqttLogger.bind(null, clientId);
+                                client.onConnectionLost = function(_param) {
+                                    var errorCode = _param.errorCode, args = _object_without_properties(_param, [
+                                        "errorCode"
+                                    ]);
+                                    if (errorCode !== 0) {
+                                        topics.forEach(function(t) {
+                                            if (_this.topicObservers.has(t)) {
+                                                _this.topicObservers.get(t).forEach(function(observer2) {
+                                                    return observer2.error(_object_spread_props(_object_spread({}, args), {
+                                                        permanent: true
+                                                    }));
+                                                });
+                                            }
+                                        });
+                                    }
+                                    topics.forEach(function(t) {
+                                        return _this.topicObservers.delete(t);
+                                    });
+                                };
+                                client.onMessageArrived = function(param) {
+                                    var destinationName = param.destinationName, payloadString = param.payloadString;
+                                    return _this.onMessage(destinationName, payloadString, selectionNames);
+                                };
+                                return [
+                                    4,
+                                    new Promise(function(resolve, reject) {
+                                        client.connect({
+                                            useSSL: url2.indexOf("wss://") === 0,
+                                            mqttVersion: 3,
+                                            onSuccess: function() {
+                                                return resolve(client);
+                                            },
+                                            onFailure: reject
+                                        });
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    4,
+                                    this.subscribeToTopics(client, topics, observer)
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    2,
+                                    client
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "subscribeToTopics",
+            value: function subscribeToTopics(client, topics, observer) {
+                var _this = this;
+                return Promise.all(topics.map(function(topic) {
+                    return _this.subscribeToTopic(client, topic, observer);
+                }));
+            }
+        },
+        {
+            key: "subscribeToTopic",
+            value: function subscribeToTopic(client, topic, observer) {
+                var _this = this;
+                return new Promise(function(resolve, reject) {
+                    client.subscribe(topic, {
+                        onSuccess: function() {
+                            if (!_this.topicObservers.has(topic)) {
+                                _this.topicObservers.set(topic, /* @__PURE__ */ new Set());
+                            }
+                            if (!_this.clientObservers.has(client.clientId)) {
+                                _this.clientObservers.set(client.clientId, {
+                                    client: client,
+                                    observers: /* @__PURE__ */ new Set()
+                                });
+                            }
+                            _this.topicObservers.get(topic).add(observer);
+                            _this.clientObservers.get(client.clientId).observers.add(observer);
+                            resolve(topic);
+                        },
+                        onFailure: reject
+                    });
+                });
+            }
+        }
+    ]);
+    return SubscriptionHandshakeLink;
+}(ApolloLink);
+// src/index.ts
+import { ApolloLink as ApolloLink4, Observable as Observable3 } from "@apollo/client/core";
+import { createHttpLink } from "@apollo/client/link/http";
+import { getMainDefinition as getMainDefinition2 } from "@apollo/client/utilities";
+// src/non-terminating-link.ts
+import { ApolloLink as ApolloLink2 } from "@apollo/client/core";
+import { setContext } from "@apollo/client/link/context";
+var NonTerminatingLink = /*#__PURE__*/ function(ApolloLink2) {
+    "use strict";
+    _inherits(NonTerminatingLink, ApolloLink2);
+    function NonTerminatingLink(contextKey, param) {
+        var link = param.link;
+        _class_call_check(this, NonTerminatingLink);
+        var _this;
+        _this = _call_super(this, NonTerminatingLink);
+        _this.contextKey = contextKey;
+        _this.link = link;
+        return _this;
+    }
+    _create_class(NonTerminatingLink, [
+        {
+            key: "request",
+            value: function request(operation, forward) {
+                var _this = this;
+                return setContext(function(_request, prevContext) {
+                    return _async_to_generator(function() {
+                        var _this, result;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _this = this;
+                                    return [
+                                        4,
+                                        new Promise(function(resolve, reject) {
+                                            _this.link.request(operation, forward).subscribe({
+                                                next: resolve,
+                                                error: reject
+                                            });
+                                        })
+                                    ];
+                                case 1:
+                                    result = _state.sent();
+                                    return [
+                                        2,
+                                        _object_spread_props(_object_spread({}, prevContext), _define_property({}, this.contextKey, result))
+                                    ];
+                            }
+                        });
+                    }).call(_this);
+                }).request(operation, forward);
+            }
+        }
+    ]);
+    return NonTerminatingLink;
+}(ApolloLink2);
+// src/realtime-subscription-handshake-link.ts
+import { ApolloLink as ApolloLink3, Observable as Observable2 } from "@apollo/client/core";
+import { filter as filter2 } from "rxjs/operators";
+import { Signer, AUTH_TYPE, USER_AGENT_HEADER, USER_AGENT } from "aws-appsync-auth-link";
+import { GraphQLError, print } from "graphql/index.js";
+import * as url from "url";
+import { v4 as uuid } from "uuid";
+// src/utils/retry.ts
+var logger2 = logger_default.extend("retry");
+var MAX_DELAY_MS = 5e3;
+var NonRetryableError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(NonRetryableError, Error1);
+    function NonRetryableError(message) {
+        _class_call_check(this, NonRetryableError);
+        var _this;
+        _this = _call_super(this, NonRetryableError, [
+            message
+        ]);
+        _this.nonRetryable = true;
+        return _this;
+    }
+    return NonRetryableError;
+}(_wrap_native_super(Error));
+var isNonRetryableError = function(obj) {
+    var key = "nonRetryable";
+    return obj && obj[key];
+};
+function retry(functionToRetry, args, delayFn) {
+    var attempt = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 1;
+    return _async_to_generator(function() {
+        var err, retryIn;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    logger2("Attempt #".concat(attempt));
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        8
+                    ]);
+                    return [
+                        4,
+                        functionToRetry.apply(void 0, args)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        8
+                    ];
+                case 3:
+                    err = _state.sent();
+                    logger2("error ".concat(err));
+                    if (isNonRetryableError(err)) {
+                        logger2("non retryable error");
+                        throw err;
+                    }
+                    retryIn = delayFn(attempt, args, err);
+                    logger2("retryIn ", retryIn);
+                    if (!(retryIn !== false)) return [
+                        3,
+                        6
+                    ];
+                    return [
+                        4,
+                        new Promise(function(res) {
+                            return setTimeout(res, retryIn);
+                        })
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        4,
+                        retry(functionToRetry, args, delayFn, attempt + 1)
+                    ];
+                case 5:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 6:
+                    throw err;
+                case 7:
+                    return [
+                        3,
+                        8
+                    ];
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function jitteredBackoff(maxDelayMs) {
+    var BASE_TIME_MS = 100;
+    var JITTER_FACTOR = 100;
+    return function(attempt) {
+        var delay = Math.pow(2, attempt) * BASE_TIME_MS + JITTER_FACTOR * Math.random();
+        return delay > maxDelayMs ? false : delay;
+    };
+}
+var jitteredExponentialRetry = function(functionToRetry, args) {
+    var maxDelayMs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : MAX_DELAY_MS;
+    return retry(functionToRetry, args, jitteredBackoff(maxDelayMs));
+};
+// src/realtime-subscription-handshake-link.ts
+var logger3 = logger_default.extend("subscriptions");
+var CONTROL_EVENTS_KEY2 = "@@controlEvents";
+var NON_RETRYABLE_CODES = [
+    400,
+    401,
+    403
+];
+var SERVICE = "appsync";
+var APPSYNC_REALTIME_HEADERS = {
+    accept: "application/json, text/javascript",
+    "content-encoding": "amz-1.0",
+    "content-type": "application/json; charset=UTF-8"
+};
+var CONNECTION_INIT_TIMEOUT = 15e3;
+var START_ACK_TIMEOUT = 15e3;
+var SERVER_KEEP_ALIVE_TIMEOUT = 1 * 60 * 1e3;
+var DEFAULT_KEEP_ALIVE_TIMEOUT = 5 * 60 * 1e3;
+var standardDomainPattern = /^https:\/\/\w{26}\.appsync\-api\.\w{2}(?:(?:\-\w{2,})+)\-\d\.amazonaws.com\/graphql$/i;
+var customDomainPath = "/realtime";
+var AppSyncRealTimeSubscriptionHandshakeLink = /*#__PURE__*/ function(ApolloLink3) {
+    "use strict";
+    _inherits(_AppSyncRealTimeSubscriptionHandshakeLink, ApolloLink3);
+    function _AppSyncRealTimeSubscriptionHandshakeLink(param) {
+        var theUrl = param.url, theRegion = param.region, theAuth = param.auth, keepAliveTimeoutMs = param.keepAliveTimeoutMs, proxy = param.proxy;
+        _class_call_check(this, _AppSyncRealTimeSubscriptionHandshakeLink);
+        var _this;
+        _this = _call_super(this, _AppSyncRealTimeSubscriptionHandshakeLink);
+        _this.socketStatus = 0 /* CLOSED */ ;
+        _this.keepAliveTimeout = void 0;
+        _this.subscriptionObserverMap = /* @__PURE__ */ new Map();
+        _this.promiseArray = [];
+        _this.url = theUrl;
+        _this.region = theRegion;
+        _this.auth = theAuth;
+        _this.proxyUrl = proxy === null || proxy === void 0 ? void 0 : proxy.url;
+        _this.keepAliveTimeout = keepAliveTimeoutMs;
+        if (_this.url && !_this.url.startsWith("https://")) {
+            logger3("WARNING: AppSync endpoint URL is not using HTTPS. Credentials may be sent unencrypted: ".concat(_this.url));
+        }
+        if (_this.proxyUrl && !_this.proxyUrl.startsWith("https://")) {
+            logger3("WARNING: Proxy URL is not using HTTPS. Credentials may be sent unencrypted: ".concat(_this.proxyUrl));
+        }
+        if (_this.keepAliveTimeout < SERVER_KEEP_ALIVE_TIMEOUT) {
+            var configName = "keepAliveTimeoutMs";
+            throw new Error("".concat(configName, " must be greater than or equal to ").concat(SERVER_KEEP_ALIVE_TIMEOUT, " (").concat(_this.keepAliveTimeout, " used)."));
+        }
+        return _this;
+    }
+    _create_class(_AppSyncRealTimeSubscriptionHandshakeLink, [
+        {
+            // Check if url matches standard domain pattern
+            key: "isCustomDomain",
+            value: function isCustomDomain(url2) {
+                return url2.match(standardDomainPattern) === null;
+            }
+        },
+        _define_property({
+            key: "request"
+        }, "value", function request(operation) {
+            var _this = this;
+            var query = operation.query, variables = operation.variables;
+            var _operation_getContext = operation.getContext(), tmp = _operation_getContext.controlMessages, _ref = tmp === void 0 ? _define_property({}, CONTROL_EVENTS_KEY2, void 0) : tmp, controlEvents = _ref[CONTROL_EVENTS_KEY2], headers = _operation_getContext.headers;
+            return new Observable2(function(observer) {
+                if (!_this.url) {
+                    observer.error({
+                        errors: [
+                            _object_spread({}, new GraphQLError("Subscribe only available for AWS AppSync endpoint"))
+                        ]
+                    });
+                    observer.complete();
+                } else {
+                    var subscriptionId = uuid();
+                    var token = _this.auth.type === AUTH_TYPE.AMAZON_COGNITO_USER_POOLS || _this.auth.type === AUTH_TYPE.OPENID_CONNECT ? _this.auth.jwtToken : null;
+                    token = _this.auth.type === AUTH_TYPE.AWS_LAMBDA ? _this.auth.token : token;
+                    var options = {
+                        appSyncGraphqlEndpoint: _this.url,
+                        authenticationType: _this.auth.type,
+                        query: print(query),
+                        region: _this.region,
+                        graphql_headers: function() {
+                            return headers;
+                        },
+                        variables: variables,
+                        apiKey: _this.auth.type === AUTH_TYPE.API_KEY ? _this.auth.apiKey : "",
+                        credentials: _this.auth.type === AUTH_TYPE.AWS_IAM ? _this.auth.credentials : null,
+                        token: token
+                    };
+                    _this._startSubscriptionWithAWSAppSyncRealTime({
+                        options: options,
+                        observer: observer,
+                        subscriptionId: subscriptionId
+                    });
+                    return function() {
+                        return _async_to_generator(function() {
+                            var subscriptionState;
+                            return _ts_generator(this, function(_state) {
+                                try {
+                                    this._verifySubscriptionAlreadyStarted(subscriptionId);
+                                    subscriptionState = this.subscriptionObserverMap.get(subscriptionId).subscriptionState;
+                                    if (subscriptionState === 1 /* CONNECTED */ ) {
+                                        this._sendUnsubscriptionMessage(subscriptionId);
+                                    } else {
+                                        throw new Error("Subscription has failed, starting to remove subscription.");
+                                    }
+                                } catch (err) {
+                                    this._removeSubscriptionObserver(subscriptionId);
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    2
+                                ];
+                            });
+                        }).call(_this);
+                    };
+                }
+            }).pipe(filter2(function(data) {
+                var tmp = data.extensions, _ref = tmp === void 0 ? {} : tmp, _ref_controlMsgType = _ref.controlMsgType, controlMsgType = _ref_controlMsgType === void 0 ? void 0 : _ref_controlMsgType;
+                var isControlMsg = typeof controlMsgType !== "undefined";
+                return controlEvents === true || !isControlMsg;
+            }));
+        }),
+        {
+            key: "_verifySubscriptionAlreadyStarted",
+            value: function _verifySubscriptionAlreadyStarted(subscriptionId) {
+                return _async_to_generator(function() {
+                    var _this, subscriptionState;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        subscriptionState = this.subscriptionObserverMap.get(subscriptionId).subscriptionState;
+                        if (subscriptionState === 0 /* PENDING */ ) {
+                            return [
+                                2,
+                                new Promise(function(res, rej) {
+                                    var _this_subscriptionObserverMap_get = _this.subscriptionObserverMap.get(subscriptionId), observer = _this_subscriptionObserverMap_get.observer, subscriptionState2 = _this_subscriptionObserverMap_get.subscriptionState, variables = _this_subscriptionObserverMap_get.variables, query = _this_subscriptionObserverMap_get.query;
+                                    _this.subscriptionObserverMap.set(subscriptionId, {
+                                        observer: observer,
+                                        subscriptionState: subscriptionState2,
+                                        variables: variables,
+                                        query: query,
+                                        subscriptionReadyCallback: res,
+                                        subscriptionFailedCallback: rej
+                                    });
+                                })
+                            ];
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "_sendUnsubscriptionMessage",
+            value: function _sendUnsubscriptionMessage(subscriptionId) {
+                try {
+                    if (this.awsRealTimeSocket && this.awsRealTimeSocket.readyState === WebSocket.OPEN && this.socketStatus === 1 /* READY */ ) {
+                        var unsubscribeMessage = {
+                            id: subscriptionId,
+                            type: "stop" /* GQL_STOP */ 
+                        };
+                        var stringToAWSRealTime = JSON.stringify(unsubscribeMessage);
+                        this.awsRealTimeSocket.send(stringToAWSRealTime);
+                        this._removeSubscriptionObserver(subscriptionId);
+                    }
+                } catch (err) {
+                    logger3({
+                        err: err
+                    });
+                }
+            }
+        },
+        {
+            key: "_removeSubscriptionObserver",
+            value: function _removeSubscriptionObserver(subscriptionId) {
+                this.subscriptionObserverMap.delete(subscriptionId);
+                setTimeout(this._closeSocketIfRequired.bind(this), 1e3);
+            }
+        },
+        {
+            key: "_closeSocketIfRequired",
+            value: function _closeSocketIfRequired() {
+                if (this.subscriptionObserverMap.size > 0) {
+                    return;
+                }
+                if (!this.awsRealTimeSocket) {
+                    this.socketStatus = 0 /* CLOSED */ ;
+                    return;
+                }
+                if (this.awsRealTimeSocket.bufferedAmount > 0) {
+                    setTimeout(this._closeSocketIfRequired.bind(this), 1e3);
+                } else {
+                    logger3("closing WebSocket...");
+                    clearTimeout(this.keepAliveTimeoutId);
+                    var tempSocket = this.awsRealTimeSocket;
+                    tempSocket.close(1e3);
+                    this.awsRealTimeSocket = null;
+                    this.socketStatus = 0 /* CLOSED */ ;
+                }
+            }
+        },
+        {
+            key: "_startSubscriptionWithAWSAppSyncRealTime",
+            value: function _startSubscriptionWithAWSAppSyncRealTime(_0) {
+                return _async_to_generator(function(param) {
+                    var _this, options, observer, subscriptionId, appSyncGraphqlEndpoint, authenticationType, query, variables, apiKey, region, _options_graphql_headers, graphql_headers, credentials, token, subscriptionState, data, dataString, headerObj, _tmp, subscriptionMessage, stringToAWSRealTime, err, _err_message, message, _ref, subscriptionFailedCallback2, _ref1, subscriptionFailedCallback, subscriptionReadyCallback;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                options = param.options, observer = param.observer, subscriptionId = param.subscriptionId;
+                                appSyncGraphqlEndpoint = options.appSyncGraphqlEndpoint, authenticationType = options.authenticationType, query = options.query, variables = options.variables, apiKey = options.apiKey, region = options.region, _options_graphql_headers = options.graphql_headers, graphql_headers = _options_graphql_headers === void 0 ? function() {
+                                    return {};
+                                } : _options_graphql_headers, credentials = options.credentials, token = options.token;
+                                subscriptionState = 0 /* PENDING */ ;
+                                data = {
+                                    query: query,
+                                    variables: variables
+                                };
+                                this.subscriptionObserverMap.set(subscriptionId, {
+                                    observer: observer,
+                                    query: query,
+                                    variables: variables,
+                                    subscriptionState: subscriptionState,
+                                    startAckTimeoutId: null
+                                });
+                                dataString = JSON.stringify(data);
+                                _tmp = [
+                                    {}
+                                ];
+                                return [
+                                    4,
+                                    this._awsRealTimeHeaderBasedAuth({
+                                        apiKey: apiKey,
+                                        appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
+                                        authenticationType: authenticationType,
+                                        payload: dataString,
+                                        canonicalUri: "",
+                                        region: region,
+                                        credentials: credentials,
+                                        token: token,
+                                        graphql_headers: graphql_headers
+                                    })
+                                ];
+                            case 1:
+                                headerObj = _object_spread_props.apply(void 0, [
+                                    _object_spread.apply(void 0, _tmp.concat([
+                                        _state.sent()
+                                    ])),
+                                    _define_property({}, USER_AGENT_HEADER, USER_AGENT)
+                                ]);
+                                subscriptionMessage = {
+                                    id: subscriptionId,
+                                    payload: {
+                                        data: dataString,
+                                        extensions: {
+                                            authorization: _object_spread({}, headerObj)
+                                        }
+                                    },
+                                    type: "start" /* GQL_START */ 
+                                };
+                                stringToAWSRealTime = JSON.stringify(subscriptionMessage);
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    this._initializeWebSocketConnection({
+                                        apiKey: apiKey,
+                                        appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
+                                        authenticationType: authenticationType,
+                                        region: region,
+                                        credentials: credentials,
+                                        token: token
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                err = _state.sent();
+                                _err_message = err.message, message = _err_message === void 0 ? "" : _err_message;
+                                observer.error({
+                                    errors: [
+                                        _object_spread({}, new GraphQLError("Connection failed: ".concat(message)))
+                                    ]
+                                });
+                                observer.complete();
+                                _ref = this.subscriptionObserverMap.get(subscriptionId) || {}, subscriptionFailedCallback2 = _ref.subscriptionFailedCallback;
+                                if (typeof subscriptionFailedCallback2 === "function") {
+                                    subscriptionFailedCallback2();
+                                }
+                                return [
+                                    2
+                                ];
+                            case 5:
+                                _ref1 = this.subscriptionObserverMap.get(subscriptionId) || {}, subscriptionFailedCallback = _ref1.subscriptionFailedCallback, subscriptionReadyCallback = _ref1.subscriptionReadyCallback;
+                                this.subscriptionObserverMap.set(subscriptionId, {
+                                    observer: observer,
+                                    subscriptionState: subscriptionState,
+                                    variables: variables,
+                                    query: query,
+                                    subscriptionReadyCallback: subscriptionReadyCallback,
+                                    subscriptionFailedCallback: subscriptionFailedCallback,
+                                    startAckTimeoutId: setTimeout(function() {
+                                        _this._timeoutStartSubscriptionAck.call(_this, subscriptionId);
+                                    }, START_ACK_TIMEOUT)
+                                });
+                                if (this.awsRealTimeSocket) {
+                                    this.awsRealTimeSocket.send(stringToAWSRealTime);
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_initializeWebSocketConnection",
+            value: function _initializeWebSocketConnection(param) {
+                var _this = this;
+                var appSyncGraphqlEndpoint = param.appSyncGraphqlEndpoint, authenticationType = param.authenticationType, apiKey = param.apiKey, region = param.region, credentials = param.credentials, token = param.token;
+                if (this.socketStatus === 1 /* READY */ ) {
+                    return;
+                }
+                return new Promise(function(res, rej) {
+                    return _async_to_generator(function() {
+                        var payloadString, headerObj, headerString, headerBase64url, discoverableEndpoint, protocols, err;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    this.promiseArray.push({
+                                        res: res,
+                                        rej: rej
+                                    });
+                                    if (!(this.socketStatus === 0 /* CLOSED */ )) return [
+                                        3,
+                                        5
+                                    ];
+                                    _state.label = 1;
+                                case 1:
+                                    _state.trys.push([
+                                        1,
+                                        4,
+                                        ,
+                                        5
+                                    ]);
+                                    this.socketStatus = 2 /* CONNECTING */ ;
+                                    payloadString = "{}";
+                                    return [
+                                        4,
+                                        this._awsRealTimeHeaderBasedAuth({
+                                            authenticationType: authenticationType,
+                                            payload: payloadString,
+                                            canonicalUri: "/connect",
+                                            apiKey: apiKey,
+                                            appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
+                                            region: region,
+                                            credentials: credentials,
+                                            token: token,
+                                            graphql_headers: function() {}
+                                        })
+                                    ];
+                                case 2:
+                                    headerObj = _state.sent();
+                                    headerString = JSON.stringify(headerObj);
+                                    headerBase64url = Buffer.from(headerString).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+                                    if (this.proxyUrl) {
+                                        discoverableEndpoint = this.proxyUrl.replace(/\/graphql$/, "").concat(customDomainPath).replace("https://", "wss://").replace("http://", "ws://");
+                                    } else if (this.isCustomDomain(appSyncGraphqlEndpoint)) {
+                                        discoverableEndpoint = appSyncGraphqlEndpoint.concat(customDomainPath);
+                                        discoverableEndpoint = discoverableEndpoint.replace("https://", "wss://").replace("http://", "ws://");
+                                    } else {
+                                        discoverableEndpoint = appSyncGraphqlEndpoint.replace("appsync-api", "appsync-realtime-api").replace("gogi-beta", "grt-beta");
+                                        discoverableEndpoint = discoverableEndpoint.replace("https://", "wss://").replace("http://", "ws://");
+                                    }
+                                    protocols = [
+                                        "graphql-ws",
+                                        "header-".concat(headerBase64url)
+                                    ];
+                                    return [
+                                        4,
+                                        this._initializeRetryableHandshake({
+                                            awsRealTimeUrl: discoverableEndpoint,
+                                            protocols: protocols
+                                        })
+                                    ];
+                                case 3:
+                                    _state.sent();
+                                    this.promiseArray.forEach(function(param) {
+                                        var res2 = param.res;
+                                        logger3("Notifying connection successful");
+                                        res2();
+                                    });
+                                    this.socketStatus = 1 /* READY */ ;
+                                    this.promiseArray = [];
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                case 4:
+                                    err = _state.sent();
+                                    this.promiseArray.forEach(function(param) {
+                                        var rej2 = param.rej;
+                                        return rej2(err);
+                                    });
+                                    this.promiseArray = [];
+                                    if (this.awsRealTimeSocket && this.awsRealTimeSocket.readyState === WebSocket.OPEN) {
+                                        this.awsRealTimeSocket.close(3001);
+                                    }
+                                    this.awsRealTimeSocket = null;
+                                    this.socketStatus = 0 /* CLOSED */ ;
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                case 5:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    }).call(_this);
+                });
+            }
+        },
+        {
+            key: "_awsRealTimeHeaderBasedAuth",
+            value: function _awsRealTimeHeaderBasedAuth(_0) {
+                return _async_to_generator(function(param) {
+                    var authenticationType, payload, canonicalUri, appSyncGraphqlEndpoint, apiKey, region, credentials, token, graphql_headers, headerHandler, handler, host, result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                authenticationType = param.authenticationType, payload = param.payload, canonicalUri = param.canonicalUri, appSyncGraphqlEndpoint = param.appSyncGraphqlEndpoint, apiKey = param.apiKey, region = param.region, credentials = param.credentials, token = param.token, graphql_headers = param.graphql_headers;
+                                headerHandler = {
+                                    API_KEY: this._awsRealTimeApiKeyHeader.bind(this),
+                                    AWS_IAM: this._awsRealTimeIAMHeader.bind(this),
+                                    OPENID_CONNECT: this._awsRealTimeAuthorizationHeader.bind(this),
+                                    AMAZON_COGNITO_USER_POOLS: this._awsRealTimeAuthorizationHeader.bind(this),
+                                    AWS_LAMBDA: this._awsRealTimeAuthorizationHeader.bind(this)
+                                };
+                                handler = headerHandler[authenticationType];
+                                if (typeof handler !== "function") {
+                                    throw new NonRetryableError("Authentication type ".concat(authenticationType, " not supported"));
+                                }
+                                host = url.parse(this.url).host;
+                                return [
+                                    4,
+                                    handler({
+                                        payload: payload,
+                                        canonicalUri: canonicalUri,
+                                        appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
+                                        apiKey: apiKey,
+                                        region: region,
+                                        host: host,
+                                        credentials: credentials,
+                                        token: token,
+                                        graphql_headers: graphql_headers
+                                    })
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_awsRealTimeAuthorizationHeader",
+            value: function _awsRealTimeAuthorizationHeader(_0) {
+                return _async_to_generator(function(param) {
+                    var host, token, graphql_headers, _tmp, _tmp1, _tmp2;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                host = param.host, token = param.token, graphql_headers = param.graphql_headers;
+                                _tmp = {};
+                                if (!(typeof token === "function")) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    token.call(void 0)
+                                ];
+                            case 1:
+                                _tmp1 = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 2:
+                                return [
+                                    4,
+                                    token
+                                ];
+                            case 3:
+                                _tmp1 = _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                _tmp2 = [
+                                    (_tmp.Authorization = _tmp1, _tmp.host = host, _tmp)
+                                ];
+                                return [
+                                    4,
+                                    graphql_headers()
+                                ];
+                            case 5:
+                                return [
+                                    2,
+                                    _object_spread.apply(void 0, _tmp2.concat([
+                                        _state.sent()
+                                    ]))
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_awsRealTimeApiKeyHeader",
+            value: function _awsRealTimeApiKeyHeader(_0) {
+                return _async_to_generator(function(param) {
+                    var apiKey, host, graphql_headers, dt, dtStr, _tmp;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                apiKey = param.apiKey, host = param.host, graphql_headers = param.graphql_headers;
+                                dt = /* @__PURE__ */ new Date();
+                                dtStr = dt.toISOString().replace(/[:\-]|\.\d{3}/g, "");
+                                _tmp = [
+                                    {
+                                        host: host,
+                                        "x-amz-date": dtStr,
+                                        "x-api-key": apiKey
+                                    }
+                                ];
+                                return [
+                                    4,
+                                    graphql_headers()
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _object_spread.apply(void 0, _tmp.concat([
+                                        _state.sent()
+                                    ]))
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_awsRealTimeIAMHeader",
+            value: function _awsRealTimeIAMHeader(_0) {
+                return _async_to_generator(function(param) {
+                    var payload, canonicalUri, appSyncGraphqlEndpoint, region, credentials, endpointInfo, creds, _ref, accessKeyId, secretAccessKey, sessionToken, formattedCredentials, request, signed_params;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                payload = param.payload, canonicalUri = param.canonicalUri, appSyncGraphqlEndpoint = param.appSyncGraphqlEndpoint, region = param.region, credentials = param.credentials;
+                                endpointInfo = {
+                                    region: region,
+                                    service: SERVICE
+                                };
+                                creds = typeof credentials === "function" ? credentials.call() : credentials || {};
+                                if (!(creds && typeof creds.getPromise === "function")) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    creds.getPromise()
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                if (!creds) {
+                                    throw new Error("No credentials");
+                                }
+                                return [
+                                    4,
+                                    creds
+                                ];
+                            case 3:
+                                _ref = _state.sent(), accessKeyId = _ref.accessKeyId, secretAccessKey = _ref.secretAccessKey, sessionToken = _ref.sessionToken;
+                                formattedCredentials = {
+                                    access_key: accessKeyId,
+                                    secret_key: secretAccessKey,
+                                    session_token: sessionToken
+                                };
+                                request = {
+                                    url: "".concat(appSyncGraphqlEndpoint).concat(canonicalUri),
+                                    body: payload,
+                                    method: "POST",
+                                    headers: _object_spread({}, APPSYNC_REALTIME_HEADERS)
+                                };
+                                signed_params = Signer.sign(request, formattedCredentials, endpointInfo);
+                                return [
+                                    2,
+                                    signed_params.headers
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_initializeRetryableHandshake",
+            value: function _initializeRetryableHandshake(_0) {
+                return _async_to_generator(function(param) {
+                    var awsRealTimeUrl, protocols;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                awsRealTimeUrl = param.awsRealTimeUrl, protocols = param.protocols;
+                                logger3("Initializaling retryable Handshake");
+                                return [
+                                    4,
+                                    jitteredExponentialRetry(this._initializeHandshake.bind(this), [
+                                        {
+                                            awsRealTimeUrl: awsRealTimeUrl,
+                                            protocols: protocols
+                                        }
+                                    ])
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_initializeHandshake",
+            value: function _initializeHandshake(_0) {
+                return _async_to_generator(function(param) {
+                    var _this, awsRealTimeUrl, protocols, err, errorType, errorCode;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                awsRealTimeUrl = param.awsRealTimeUrl, protocols = param.protocols;
+                                logger3("Initializing handshake ".concat(awsRealTimeUrl));
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    function() {
+                                        return new Promise(function(res, rej) {
+                                            var newSocket = _AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket(awsRealTimeUrl, protocols);
+                                            newSocket.onerror = function() {
+                                                logger3("WebSocket connection error");
+                                            };
+                                            newSocket.onclose = function() {
+                                                rej(new Error("Connection handshake error"));
+                                            };
+                                            newSocket.onopen = function() {
+                                                _this.awsRealTimeSocket = newSocket;
+                                                return res();
+                                            };
+                                        });
+                                    }()
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    4,
+                                    function() {
+                                        return new Promise(function(res, rej) {
+                                            var checkAckOk = function checkAckOk() {
+                                                if (!ackOk) {
+                                                    rej(new Error("Connection timeout: ack from AWSRealTime was not received on ".concat(CONNECTION_INIT_TIMEOUT, " ms")));
+                                                }
+                                            };
+                                            var ackOk = false;
+                                            _this.awsRealTimeSocket.onerror = function(error) {
+                                                logger3("WebSocket closed ".concat(JSON.stringify(error)));
+                                            };
+                                            _this.awsRealTimeSocket.onclose = function(event) {
+                                                logger3("WebSocket closed ".concat(event.reason));
+                                                rej(new Error(JSON.stringify(event)));
+                                            };
+                                            _this.awsRealTimeSocket.onmessage = function(message) {
+                                                var data;
+                                                try {
+                                                    data = JSON.parse(message.data);
+                                                } catch (e) {
+                                                    logger3("Failed to parse WebSocket message");
+                                                    return;
+                                                }
+                                                var type = data.type, tmp = data.payload, _ref = tmp === void 0 ? {} : tmp, _ref_connectionTimeoutMs = _ref.connectionTimeoutMs, connectionTimeoutMs = _ref_connectionTimeoutMs === void 0 ? DEFAULT_KEEP_ALIVE_TIMEOUT : _ref_connectionTimeoutMs;
+                                                logger3("subscription message from AWS AppSyncRealTime: ".concat(type));
+                                                if (type === "connection_ack" /* GQL_CONNECTION_ACK */ ) {
+                                                    ackOk = true;
+                                                    var validTimeout = typeof connectionTimeoutMs === "number" && connectionTimeoutMs >= SERVER_KEEP_ALIVE_TIMEOUT ? connectionTimeoutMs : DEFAULT_KEEP_ALIVE_TIMEOUT;
+                                                    var _this_keepAliveTimeout;
+                                                    _this.keepAliveTimeout = (_this_keepAliveTimeout = _this.keepAliveTimeout) !== null && _this_keepAliveTimeout !== void 0 ? _this_keepAliveTimeout : validTimeout;
+                                                    _this.awsRealTimeSocket.onmessage = _this._handleIncomingSubscriptionMessage.bind(_this);
+                                                    _this.awsRealTimeSocket.onerror = function(err) {
+                                                        logger3(err);
+                                                        _this._errorDisconnect("Connection closed" /* CONNECTION_CLOSED */ );
+                                                    };
+                                                    _this.awsRealTimeSocket.onclose = function(event) {
+                                                        logger3("WebSocket closed ".concat(event.reason));
+                                                        _this._errorDisconnect("Connection closed" /* CONNECTION_CLOSED */ );
+                                                    };
+                                                    res("Cool, connected to AWS AppSyncRealTime");
+                                                    return;
+                                                }
+                                                if (type === "connection_error" /* GQL_CONNECTION_ERROR */ ) {
+                                                    var tmp1 = data.payload, _ref1 = tmp1 === void 0 ? {} : tmp1, tmp2 = _ref1.errors, _ref2 = _sliced_to_array(tmp2 === void 0 ? [] : tmp2, 1), tmp3 = _ref2[0], _ref3 = tmp3 === void 0 ? {} : tmp3, _ref_errorType = _ref3.errorType, errorType = _ref_errorType === void 0 ? "" : _ref_errorType, _ref_errorCode = _ref3.errorCode, errorCode = _ref_errorCode === void 0 ? 0 : _ref_errorCode;
+                                                    rej({
+                                                        errorType: errorType,
+                                                        errorCode: errorCode
+                                                    });
+                                                }
+                                            };
+                                            var gqlInit = {
+                                                type: "connection_init" /* GQL_CONNECTION_INIT */ 
+                                            };
+                                            _this.awsRealTimeSocket.send(JSON.stringify(gqlInit));
+                                            setTimeout(checkAckOk.bind(_this), CONNECTION_INIT_TIMEOUT);
+                                        });
+                                    }()
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                err = _state.sent();
+                                errorType = err.errorType, errorCode = err.errorCode;
+                                if (NON_RETRYABLE_CODES.indexOf(errorCode) >= 0) {
+                                    throw new NonRetryableError(errorType);
+                                } else if (errorType) {
+                                    throw new Error(errorType);
+                                } else {
+                                    throw err;
+                                }
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "_handleIncomingSubscriptionMessage",
+            value: function _handleIncomingSubscriptionMessage(message) {
+                var parsed;
+                try {
+                    parsed = JSON.parse(message.data);
+                } catch (e) {
+                    logger3("Failed to parse incoming subscription message");
+                    return;
+                }
+                var _parsed_id = parsed.id, id = _parsed_id === void 0 ? "" : _parsed_id, payload = parsed.payload, type = parsed.type;
+                logger3("subscription message from AWS AppSync RealTime: ".concat(type, " id: ").concat(id));
+                var _ref = this.subscriptionObserverMap.get(id) || {}, _ref_observer = _ref.observer, observer = _ref_observer === void 0 ? null : _ref_observer, _ref_query = _ref.query, query = _ref_query === void 0 ? "" : _ref_query, _ref_variables = _ref.variables, variables = _ref_variables === void 0 ? {} : _ref_variables, _ref_startAckTimeoutId = _ref.startAckTimeoutId, startAckTimeoutId = _ref_startAckTimeoutId === void 0 ? 0 : _ref_startAckTimeoutId, _ref_subscriptionReadyCallback = _ref.subscriptionReadyCallback, subscriptionReadyCallback = _ref_subscriptionReadyCallback === void 0 ? null : _ref_subscriptionReadyCallback, _ref_subscriptionFailedCallback = _ref.subscriptionFailedCallback, subscriptionFailedCallback = _ref_subscriptionFailedCallback === void 0 ? null : _ref_subscriptionFailedCallback;
+                logger3({
+                    id: id,
+                    observer: observer,
+                    query: query,
+                    variables: variables
+                });
+                if (type === "data" /* GQL_DATA */  && payload && payload.data) {
+                    if (observer) {
+                        observer.next(payload);
+                    } else {
+                        logger3("observer not found for id: ".concat(id));
+                    }
+                    return;
+                }
+                if (type === "start_ack" /* GQL_START_ACK */ ) {
+                    logger3("subscription ready for ".concat(JSON.stringify({
+                        query: query,
+                        variables: variables
+                    })));
+                    if (typeof subscriptionReadyCallback === "function") {
+                        subscriptionReadyCallback();
+                    }
+                    clearTimeout(startAckTimeoutId);
+                    if (observer) {
+                        observer.next({
+                            data: payload,
+                            extensions: {
+                                controlMsgType: "CONNECTED"
+                            }
+                        });
+                    } else {
+                        logger3("observer not found for id: ".concat(id));
+                    }
+                    var subscriptionState = 1 /* CONNECTED */ ;
+                    this.subscriptionObserverMap.set(id, {
+                        observer: observer,
+                        query: query,
+                        variables: variables,
+                        startAckTimeoutId: null,
+                        subscriptionState: subscriptionState,
+                        subscriptionReadyCallback: subscriptionReadyCallback,
+                        subscriptionFailedCallback: subscriptionFailedCallback
+                    });
+                    return;
+                }
+                if (type === "ka" /* GQL_CONNECTION_KEEP_ALIVE */ ) {
+                    clearTimeout(this.keepAliveTimeoutId);
+                    this.keepAliveTimeoutId = setTimeout(this._errorDisconnect.bind(this, "Timeout disconnect" /* TIMEOUT_DISCONNECT */ ), this.keepAliveTimeout);
+                    return;
+                }
+                if (type === "error" /* GQL_ERROR */ ) {
+                    var subscriptionState1 = 2 /* FAILED */ ;
+                    this.subscriptionObserverMap.set(id, {
+                        observer: observer,
+                        query: query,
+                        variables: variables,
+                        startAckTimeoutId: startAckTimeoutId,
+                        subscriptionReadyCallback: subscriptionReadyCallback,
+                        subscriptionFailedCallback: subscriptionFailedCallback,
+                        subscriptionState: subscriptionState1
+                    });
+                    clearTimeout(startAckTimeoutId);
+                    if (observer) {
+                        observer.error({
+                            errors: [
+                                _object_spread({}, new GraphQLError("Connection failed: ".concat(JSON.stringify(payload))))
+                            ]
+                        });
+                        observer.complete();
+                    } else {
+                        logger3("observer not found for id: ".concat(id));
+                    }
+                    if (typeof subscriptionFailedCallback === "function") {
+                        subscriptionFailedCallback();
+                    }
+                }
+            }
+        },
+        {
+            key: "_errorDisconnect",
+            value: function _errorDisconnect(msg) {
+                logger3("Disconnect error: ".concat(msg));
+                this.subscriptionObserverMap.forEach(function(param) {
+                    var observer = param.observer;
+                    if (observer && !observer.closed) {
+                        observer.error({
+                            errors: [
+                                _object_spread({}, new GraphQLError(msg))
+                            ]
+                        });
+                    }
+                });
+                this.subscriptionObserverMap.clear();
+                if (this.awsRealTimeSocket) {
+                    this.awsRealTimeSocket.close();
+                }
+                this.socketStatus = 0 /* CLOSED */ ;
+            }
+        },
+        {
+            key: "_timeoutStartSubscriptionAck",
+            value: function _timeoutStartSubscriptionAck(subscriptionId) {
+                var _ref = this.subscriptionObserverMap.get(subscriptionId) || {}, observer = _ref.observer, query = _ref.query, variables = _ref.variables;
+                if (!observer) {
+                    return;
+                }
+                this.subscriptionObserverMap.set(subscriptionId, {
+                    observer: observer,
+                    query: query,
+                    variables: variables,
+                    subscriptionState: 2 /* FAILED */ 
+                });
+                if (observer && !observer.closed) {
+                    observer.error({
+                        errors: [
+                            _object_spread({}, new GraphQLError("Subscription timeout ".concat(JSON.stringify({
+                                query: query,
+                                variables: variables
+                            }))))
+                        ]
+                    });
+                    observer.complete();
+                }
+                logger3("timeoutStartSubscription", JSON.stringify({
+                    query: query,
+                    variables: variables
+                }));
+            }
+        }
+    ], [
+        {
+            key: "createWebSocket",
+            value: function createWebSocket(awsRealTimeUrl, protocol) {
+                return new WebSocket(awsRealTimeUrl, protocol);
+            }
+        }
+    ]);
+    return _AppSyncRealTimeSubscriptionHandshakeLink;
+}(ApolloLink3);
+// src/index.ts
+function createSubscriptionHandshakeLink(infoOrUrl, theResultsFetcherLink) {
+    var resultsFetcherLink, subscriptionLinks;
+    if (typeof infoOrUrl === "string") {
+        resultsFetcherLink = theResultsFetcherLink || createHttpLink({
+            uri: infoOrUrl
+        });
+        subscriptionLinks = ApolloLink4.from([
+            new NonTerminatingLink("controlMessages", _define_property({}, "link", new ApolloLink4(function(operation, _forward) {
+                return new Observable3(function(observer) {
+                    var _operation_variables = operation.variables, controlEvents = _operation_variables[CONTROL_EVENTS_KEY], variables = _object_without_properties(operation.variables, [
+                        CONTROL_EVENTS_KEY
+                    ].map(_to_property_key));
+                    if (typeof controlEvents !== "undefined") {
+                        operation.variables = variables;
+                    }
+                    observer.next(_define_property({}, CONTROL_EVENTS_KEY, controlEvents));
+                    return function() {};
+                });
+            }))),
+            new NonTerminatingLink("subsInfo", {
+                link: resultsFetcherLink
+            }),
+            new SubscriptionHandshakeLink("subsInfo")
+        ]);
+    } else {
+        var url2 = infoOrUrl.url;
+        resultsFetcherLink = theResultsFetcherLink || createHttpLink({
+            uri: url2
+        });
+        subscriptionLinks = new AppSyncRealTimeSubscriptionHandshakeLink(infoOrUrl);
+    }
+    return ApolloLink4.split(function(operation) {
+        var query = operation.query;
+        var _getMainDefinition2 = getMainDefinition2(query), kind = _getMainDefinition2.kind, graphqlOperation = _getMainDefinition2.operation;
+        var isSubscription = kind === "OperationDefinition" && graphqlOperation === "subscription";
+        return isSubscription;
+    }, subscriptionLinks, resultsFetcherLink);
+}
+export { CONTROL_EVENTS_KEY, createSubscriptionHandshakeLink }; /*!
+ * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */  /*!
+ * Copyright 2017-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */