{"version":3,"file":"js/vendors-node_modules_mixer_postmessage-rpc_dist_rpc_js-08be4b34e7de34bb0083.js","mappings":"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","sources":["webpack://stornaway/./node_modules/@mixer/postmessage-rpc/dist/error.js","webpack://stornaway/./node_modules/@mixer/postmessage-rpc/dist/reorder.js","webpack://stornaway/./node_modules/@mixer/postmessage-rpc/dist/rpc.js","webpack://stornaway/./node_modules/@mixer/postmessage-rpc/dist/types.js","webpack://stornaway/./node_modules/eventemitter3/index.js"],"sourcesContent":["\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * An RPCError can be thrown in socket.call() if bad input is\n * passed to the service.\n */\nvar RPCError = /** @class */ (function (_super) {\n    __extends(RPCError, _super);\n    function RPCError(code, message, path) {\n        var _this = _super.call(this, \"Error #\" + code + \": \" + message) || this;\n        _this.code = code;\n        _this.message = message;\n        _this.path = path;\n        // Patch for ES5 compilation target errors:\n        Object.setPrototypeOf(_this, RPCError.prototype);\n        return _this;\n    }\n    RPCError.prototype.toReplyError = function () {\n        return {\n            code: this.code,\n            message: this.message,\n            path: this.path,\n        };\n    };\n    return RPCError;\n}(Error));\nexports.RPCError = RPCError;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Reorder is a utility responsible for reording incoming messages.\n */\nvar Reorder = /** @class */ (function () {\n    function Reorder() {\n        /**\n         * Last call we got which was in sequence..\n         */\n        this.lastSequentialCall = -1;\n        /**\n         * Queue of messages to send out once reordered data comes back.\n         */\n        this.queue = [];\n    }\n    /**\n     * Resets the queue and call counter to the given value.\n     */\n    Reorder.prototype.reset = function (counter) {\n        this.lastSequentialCall = counter - 1;\n        this.queue = [];\n    };\n    /**\n     * Appends a message to the reorder queue. Returns all messages which\n     * are good to send out.\n     */\n    Reorder.prototype.append = function (packet) {\n        if (packet.counter <= this.lastSequentialCall + 1) {\n            var list = [packet];\n            this.lastSequentialCall = packet.counter;\n            this.replayQueue(list);\n            return list;\n        }\n        for (var i = 0; i < this.queue.length; i++) {\n            if (this.queue[i].counter > packet.counter) {\n                this.queue.splice(i, 0, packet);\n                return [];\n            }\n        }\n        this.queue.push(packet);\n        return [];\n    };\n    Reorder.prototype.replayQueue = function (list) {\n        while (this.queue.length) {\n            var next = this.queue[0];\n            if (next.counter > this.lastSequentialCall + 1) {\n                return;\n            }\n            list.push(this.queue.shift());\n            this.lastSequentialCall = next.counter;\n        }\n    };\n    return Reorder;\n}());\nexports.Reorder = Reorder;\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar eventemitter3_1 = require(\"eventemitter3\");\nvar error_1 = require(\"./error\");\nvar reorder_1 = require(\"./reorder\");\nvar types_1 = require(\"./types\");\nfunction objToError(obj) {\n    return new error_1.RPCError(obj.code, obj.message, obj.path);\n}\n/**\n * Magic ID used for the \"ready\" call.\n */\nvar magicReadyCallId = -1;\n/**\n * Primitive postMessage based RPC.\n */\nvar RPC = /** @class */ (function (_super) {\n    __extends(RPC, _super);\n    /**\n     * Creates a new RPC instance. Note: you should use the `rpc` singleton,\n     * rather than creating this class directly, in your controls.\n     */\n    function RPC(options) {\n        var _this = _super.call(this) || this;\n        _this.options = options;\n        /**\n         * A map of IDs to callbacks we'll fire whenever the remote frame responds.\n         */\n        _this.calls = Object.create(null);\n        /**\n         * Counter to track the sequence number of our calls for reordering.\n         * Incremented each time we send a message.\n         */\n        _this.callCounter = 0;\n        /**\n         * Reorder utility for incoming messages.\n         */\n        _this.reorder = new reorder_1.Reorder();\n        _this.listener = function (ev) {\n            // If we got data that wasn't a string or could not be parsed, or was\n            // from a different remote, it's not for us.\n            if (_this.options.origin && _this.options.origin !== '*' && ev.origin !== _this.options.origin) {\n                return;\n            }\n            var packet;\n            try {\n                packet = JSON.parse(ev.data);\n            }\n            catch (e) {\n                return;\n            }\n            if (!types_1.isRPCMessage(packet) || packet.serviceID !== _this.options.serviceId) {\n                return;\n            }\n            // postMessage does not guarantee message order, reorder messages as needed.\n            // Reset the call counter when we get a \"ready\" so that the other end sees\n            // calls starting from 0.\n            if (_this.isReadySignal(packet)) {\n                var params = packet.type === 'method' ? packet.params : packet.result;\n                if (params && params.protocolVersion) {\n                    _this.remoteProtocolVersion = params.protocolVersion;\n                }\n                else {\n                    _this.remoteProtocolVersion = _this.remoteProtocolVersion;\n                }\n                _this.callCounter = 0;\n                _this.reorder.reset(packet.counter);\n                _this.emit('isReady', true);\n            }\n            for (var _i = 0, _a = _this.reorder.append(packet); _i < _a.length; _i++) {\n                var p = _a[_i];\n                _this.emit('recvData', p);\n                _this.dispatchIncoming(p);\n            }\n        };\n        _this.unsubscribeCallback = (options.receiver || types_1.defaultRecievable).readMessages(_this.listener);\n        // Both sides will fire \"ready\" when they're set up. When either we get\n        // a ready or the other side successfully responds that they're ready,\n        // resolve the \"ready\" promise.\n        _this.isReady = new Promise(function (resolve) {\n            var response = { protocolVersion: options.protocolVersion || '1.0' };\n            _this.expose('ready', function () {\n                resolve();\n                return response;\n            });\n            _this.call('ready', response)\n                .then(resolve)\n                .catch(resolve);\n        });\n        return _this;\n    }\n    /**\n     * Create instantiates a new RPC instance and waits until it's ready\n     * before returning.\n     */\n    RPC.prototype.create = function (options) {\n        var rpc = new RPC(options);\n        return rpc.isReady.then(function () { return rpc; });\n    };\n    /**\n     * Attaches a method callable by the other window, to this one. The handler\n     * function will be invoked with whatever the other window gives us. Can\n     * return a Promise, or the results directly.\n     *\n     * @param {string} method\n     * @param {function(params: any): Promise.<*>|*} handler\n     */\n    RPC.prototype.expose = function (method, handler) {\n        var _this = this;\n        this.on(method, function (data) {\n            if (data.discard) {\n                handler(data.params);\n                return;\n            }\n            // tslint:disable-next-line\n            new Promise(function (resolve) { return resolve(handler(data.params)); })\n                .then(function (result) {\n                return ({\n                    type: 'reply',\n                    serviceID: _this.options.serviceId,\n                    id: data.id,\n                    result: result,\n                });\n            })\n                .catch(function (err) {\n                return ({\n                    type: 'reply',\n                    serviceID: _this.options.serviceId,\n                    id: data.id,\n                    error: err instanceof error_1.RPCError\n                        ? err.toReplyError()\n                        : { code: 0, message: err.stack || err.message },\n                });\n            })\n                .then(function (packet) {\n                _this.emit('sendReply', packet);\n                _this.post(packet);\n            });\n        });\n        return this;\n    };\n    /**\n     * Makes an RPC call out to the target window.\n     *\n     * @param {string} method\n     * @param {*} params\n     * @param {boolean} [waitForReply=true]\n     * @return {Promise.<object> | undefined} If waitForReply is true, a\n     * promise is returned that resolves once the server responds.\n     */\n    RPC.prototype.call = function (method, params, waitForReply) {\n        var _this = this;\n        if (waitForReply === void 0) { waitForReply = true; }\n        var id = method === 'ready' ? magicReadyCallId : this.callCounter;\n        var packet = {\n            type: 'method',\n            serviceID: this.options.serviceId,\n            id: id,\n            params: params,\n            method: method,\n            discard: !waitForReply,\n        };\n        this.emit('sendMethod', packet);\n        this.post(packet);\n        if (!waitForReply) {\n            return;\n        }\n        return new Promise(function (resolve, reject) {\n            _this.calls[id] = function (err, res) {\n                if (err) {\n                    reject(err);\n                }\n                else {\n                    resolve(res);\n                }\n            };\n        });\n    };\n    /**\n     * Tears down resources associated with the RPC client.\n     */\n    RPC.prototype.destroy = function () {\n        this.emit('destroy');\n        this.unsubscribeCallback();\n    };\n    /**\n     * Returns the protocol version that the remote client implements. This\n     * will return `undefined` until we get a `ready` event.\n     * @return {string | undefined}\n     */\n    RPC.prototype.remoteVersion = function () {\n        return this.remoteProtocolVersion;\n    };\n    RPC.prototype.handleReply = function (packet) {\n        var handler = this.calls[packet.id];\n        if (!handler) {\n            return;\n        }\n        if (packet.error) {\n            handler(objToError(packet.error), null);\n        }\n        else {\n            handler(null, packet.result);\n        }\n        delete this.calls[packet.id];\n    };\n    RPC.prototype.post = function (message) {\n        message.counter = this.callCounter++;\n        this.options.target.postMessage(JSON.stringify(message), this.options.origin || '*');\n    };\n    RPC.prototype.isReadySignal = function (packet) {\n        if (packet.type === 'method' && packet.method === 'ready') {\n            return true;\n        }\n        if (packet.type === 'reply' && packet.id === magicReadyCallId) {\n            return true;\n        }\n        return false;\n    };\n    RPC.prototype.dispatchIncoming = function (packet) {\n        switch (packet.type) {\n            case 'method':\n                this.emit('recvMethod', packet);\n                if (this.listeners(packet.method).length > 0) {\n                    this.emit(packet.method, packet);\n                    return;\n                }\n                this.post({\n                    type: 'reply',\n                    serviceID: this.options.serviceId,\n                    id: packet.id,\n                    error: { code: 4003, message: \"Unknown method name \\\"\" + packet.method + \"\\\"\" },\n                    result: null,\n                });\n                break;\n            case 'reply':\n                this.emit('recvReply', packet);\n                this.handleReply(packet);\n                break;\n            default:\n            // Ignore\n        }\n    };\n    return RPC;\n}(eventemitter3_1.EventEmitter));\nexports.RPC = RPC;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Checks whether the message duck-types into an Interactive message.\n * This is needed to distinguish between postmessages that we get,\n * and postmessages from other sources.\n */\nfunction isRPCMessage(data) {\n    return (data.type === 'method' || data.type === 'reply') && typeof data.counter === 'number';\n}\nexports.isRPCMessage = isRPCMessage;\n/**\n * Default `IRecievable` implementation that listens on the window.\n */\nexports.defaultRecievable = {\n    readMessages: function (callback) {\n        window.addEventListener('message', callback);\n        return function () { return window.removeEventListener('message', callback); };\n    },\n};\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n"],"names":["extendStatics","__extends","this","Object","setPrototypeOf","__proto__","Array","d","b","p","hasOwnProperty","__","constructor","prototype","create","defineProperty","exports","value","RPCError","_super","code","message","path","_this","call","toReplyError","Error","Reorder","lastSequentialCall","queue","reset","counter","append","packet","list","replayQueue","i","length","splice","push","next","shift","eventemitter3_1","error_1","reorder_1","types_1","RPC","options","calls","callCounter","reorder","listener","ev","origin","JSON","parse","data","e","isRPCMessage","serviceID","serviceId","isReadySignal","params","type","result","protocolVersion","remoteProtocolVersion","emit","_i","_a","dispatchIncoming","unsubscribeCallback","receiver","defaultRecievable","readMessages","isReady","Promise","resolve","response","expose","then","catch","rpc","method","handler","on","discard","id","err","error","stack","post","waitForReply","reject","res","destroy","remoteVersion","handleReply","obj","target","postMessage","stringify","listeners","EventEmitter","callback","window","addEventListener","removeEventListener","has","prefix","Events","EE","fn","context","once","addListener","emitter","event","TypeError","evt","_events","_eventsCount","clearEvent","eventNames","events","name","names","slice","getOwnPropertySymbols","concat","handlers","l","ee","listenerCount","a1","a2","a3","a4","a5","args","len","arguments","removeListener","undefined","apply","j","removeAllListeners","off","prefixed","module"],"sourceRoot":""}