@bearer/js
Version:
A JavaScript library for working with Bearer integrations
943 lines (925 loc) • 213 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global.bearer = factory());
}(this, (function () { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
t[p[i]] = s[p[i]];
return t;
}
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
/**
* Returns a function, that, as long as it continues to be invoked, will not
* be triggered. The function will be called after it stops being called for
* N milliseconds. If `immediate` is passed, trigger the function on the
* leading edge, instead of the trailing. The function also has a property 'clear'
* that is a function which will clear the timer to prevent previously scheduled executions.
*
* @source underscore.js
* @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
* @param {Function} function to wrap
* @param {Number} timeout in ms (`100`)
* @param {Boolean} whether to execute at the beginning (`false`)
* @api public
*/
function debounce(func, wait, immediate){
var timeout, args, context, timestamp, result;
if (null == wait) wait = 100;
function later() {
var last = Date.now() - timestamp;
if (last < wait && last >= 0) {
timeout = setTimeout(later, wait - last);
} else {
timeout = null;
if (!immediate) {
result = func.apply(context, args);
context = args = null;
}
}
}
var debounced = function(){
context = this;
args = arguments;
timestamp = Date.now();
var callNow = immediate && !timeout;
if (!timeout) timeout = setTimeout(later, wait);
if (callNow) {
result = func.apply(context, args);
context = args = null;
}
return result;
};
debounced.clear = function() {
if (timeout) {
clearTimeout(timeout);
timeout = null;
}
};
debounced.flush = function() {
if (timeout) {
result = func.apply(context, args);
context = args = null;
clearTimeout(timeout);
timeout = null;
}
};
return debounced;
}
// Adds compatibility for ES modules
debounce.debounce = debounce;
var debounce_1 = debounce;
var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x.default : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var postRobot = createCommonjsModule(function (module, exports) {
!function(root, factory) {
module.exports = factory();
}("undefined" != typeof self ? self : commonjsGlobal, function() {
return function(modules) {
var installedModules = {};
function __webpack_require__(moduleId) {
if (installedModules[moduleId]) return installedModules[moduleId].exports;
var module = installedModules[moduleId] = {
i: moduleId,
l: !1,
exports: {}
};
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
module.l = !0;
return module.exports;
}
__webpack_require__.m = modules;
__webpack_require__.c = installedModules;
__webpack_require__.d = function(exports, name, getter) {
__webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {
configurable: !1,
enumerable: !0,
get: getter
});
};
__webpack_require__.n = function(module) {
var getter = module && module.__esModule ? function() {
return module.default;
} : function() {
return module;
};
__webpack_require__.d(getter, "a", getter);
return getter;
};
__webpack_require__.o = function(object, property) {
return Object.prototype.hasOwnProperty.call(object, property);
};
__webpack_require__.p = "";
return __webpack_require__(__webpack_require__.s = "./src/index.js");
}({
"./node_modules/cross-domain-utils/src/constants.js": function(module, __webpack_exports__, __webpack_require__) {
__webpack_require__.d(__webpack_exports__, "a", function() {
return PROTOCOL;
});
__webpack_require__.d(__webpack_exports__, "b", function() {
return WILDCARD;
});
var PROTOCOL = {
MOCK: "mock:",
FILE: "file:",
ABOUT: "about:"
}, WILDCARD = "*";
},
"./node_modules/cross-domain-utils/src/index.js": function(module, __webpack_exports__, __webpack_require__) {
var __WEBPACK_IMPORTED_MODULE_0__utils__ = __webpack_require__("./node_modules/cross-domain-utils/src/utils.js");
__webpack_require__.d(__webpack_exports__, "getActualDomain", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.a;
});
__webpack_require__.d(__webpack_exports__, "getAncestor", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.b;
});
__webpack_require__.d(__webpack_exports__, "getDomain", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.c;
});
__webpack_require__.d(__webpack_exports__, "getUserAgent", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.d;
});
__webpack_require__.d(__webpack_exports__, "isActuallySameDomain", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.e;
});
__webpack_require__.d(__webpack_exports__, "isAncestor", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.f;
});
__webpack_require__.d(__webpack_exports__, "isIframe", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.g;
});
__webpack_require__.d(__webpack_exports__, "isPopup", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.h;
});
__webpack_require__.d(__webpack_exports__, "isWindow", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.i;
});
__webpack_require__.d(__webpack_exports__, "isWindowClosed", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.j;
});
__webpack_require__.d(__webpack_exports__, "matchDomain", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.k;
});
__webpack_require__.d(__webpack_exports__, "stringifyDomainPattern", function() {
return __WEBPACK_IMPORTED_MODULE_0__utils__.l;
});
var __WEBPACK_IMPORTED_MODULE_1__types__ = __webpack_require__("./node_modules/cross-domain-utils/src/types.js");
__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__types__), __webpack_require__("./node_modules/cross-domain-utils/src/constants.js");
},
"./node_modules/cross-domain-utils/src/types.js": function(module, exports) {},
"./node_modules/cross-domain-utils/src/utils.js": function(module, __webpack_exports__, __webpack_require__) {
function isRegex(item) {
return "[object RegExp]" === Object.prototype.toString.call(item);
}
var constants = __webpack_require__("./node_modules/cross-domain-utils/src/constants.js");
__webpack_exports__.a = getActualDomain;
__webpack_exports__.c = getDomain;
__webpack_exports__.e = isActuallySameDomain;
__webpack_exports__.j = function(win) {
var allowMock = !(arguments.length > 1 && void 0 !== arguments[1]) || arguments[1];
try {
if (win === window) return !1;
} catch (err) {
return !0;
}
try {
if (!win) return !0;
} catch (err) {
return !0;
}
try {
if (win.closed) return !0;
} catch (err) {
return !err || err.message !== IE_WIN_ACCESS_ERROR;
}
if (allowMock && function(win) {
if (!isActuallySameDomain(win)) return !1;
try {
if (win === window) return !0;
if (isAboutProtocol(win) && canReadFromWindow(win)) return !0;
if (getDomain(window) === getDomain(win)) return !0;
} catch (err) {}
return !1;
}(win)) try {
if (win.mockclosed) return !0;
} catch (err) {}
try {
if (!win.parent || !win.top) return !0;
} catch (err) {}
var iframeIndex = function(collection, item) {
for (var i = 0; i < collection.length; i++) try {
if (collection[i] === item) return i;
} catch (err) {}
return -1;
}(iframeWindows, win);
if (-1 !== iframeIndex) {
var frame = iframeFrames[iframeIndex];
if (frame && function(frame) {
if (!frame.contentWindow) return !0;
if (!frame.parentNode) return !0;
var doc = frame.ownerDocument;
return !(!doc || !doc.documentElement || doc.documentElement.contains(frame));
}(frame)) return !0;
}
return !1;
};
__webpack_exports__.d = function(win) {
return (win = win || window).navigator.mockUserAgent || win.navigator.userAgent;
};
__webpack_exports__.b = getAncestor;
__webpack_exports__.f = function(parent, child) {
var actualParent = getAncestor(child);
if (actualParent) return actualParent === parent;
if (child === parent) return !1;
if (function(win) {
if (win) {
try {
if (win.top) return win.top;
} catch (err) {}
if (getParent(win) === win) return win;
try {
if (isAncestorParent(window, win) && window.top) return window.top;
} catch (err) {}
try {
if (isAncestorParent(win, window) && window.top) return window.top;
} catch (err) {}
for (var _i7 = 0, _getAllChildFrames4 = function getAllChildFrames(win) {
for (var result = [], _i3 = 0, _getFrames2 = getFrames(win), _length2 = null == _getFrames2 ? 0 : _getFrames2.length; _i3 < _length2; _i3++) {
var frame = _getFrames2[_i3];
result.push(frame);
for (var _i5 = 0, _getAllChildFrames2 = getAllChildFrames(frame), _length4 = null == _getAllChildFrames2 ? 0 : _getAllChildFrames2.length; _i5 < _length4; _i5++) {
var childFrame = _getAllChildFrames2[_i5];
result.push(childFrame);
}
}
return result;
}(win), _length6 = null == _getAllChildFrames4 ? 0 : _getAllChildFrames4.length; _i7 < _length6; _i7++) {
var frame = _getAllChildFrames4[_i7];
try {
if (frame.top) return frame.top;
} catch (err) {}
if (getParent(frame) === frame) return frame;
}
}
}(child) === child) return !1;
for (var _i15 = 0, _getFrames8 = getFrames(parent), _length14 = null == _getFrames8 ? 0 : _getFrames8.length; _i15 < _length14; _i15++) if (_getFrames8[_i15] === child) return !0;
return !1;
};
__webpack_exports__.h = function() {
return Boolean(getOpener(window));
};
__webpack_exports__.g = function() {
return Boolean(getParent(window));
};
__webpack_exports__.k = function matchDomain(pattern, origin) {
if ("string" == typeof pattern) {
if ("string" == typeof origin) return pattern === constants.b || origin === pattern;
if (isRegex(origin)) return !1;
if (Array.isArray(origin)) return !1;
}
return isRegex(pattern) ? isRegex(origin) ? pattern.toString() === origin.toString() : !Array.isArray(origin) && Boolean(origin.match(pattern)) : !!Array.isArray(pattern) && (Array.isArray(origin) ? JSON.stringify(pattern) === JSON.stringify(origin) : !isRegex(origin) && pattern.some(function(subpattern) {
return matchDomain(subpattern, origin);
}));
};
__webpack_exports__.l = function(pattern) {
return Array.isArray(pattern) ? "(" + pattern.join(" | ") + ")" : isRegex(pattern) ? "RegExp(" + pattern.toString() : pattern.toString();
};
__webpack_exports__.i = function(obj) {
try {
if (obj === window) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if ("[object Window]" === Object.prototype.toString.call(obj)) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (window.Window && obj instanceof window.Window) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && obj.self === obj) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && obj.parent === obj) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if (obj && obj.top === obj) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
obj && obj.__cross_domain_utils_window_check__;
} catch (err) {
return !0;
}
return !1;
};
var IE_WIN_ACCESS_ERROR = "Call was rejected by callee.\r\n";
function isAboutProtocol() {
return (arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : window).location.protocol === constants.a.ABOUT;
}
function getParent(win) {
if (win) try {
if (win.parent && win.parent !== win) return win.parent;
} catch (err) {}
}
function getOpener(win) {
if (win && !getParent(win)) try {
return win.opener;
} catch (err) {}
}
function canReadFromWindow(win) {
try {
win && win.location && win.location.href;
return !0;
} catch (err) {}
return !1;
}
function getActualDomain(win) {
var location = (win = win || window).location;
if (!location) throw new Error("Can not read window location");
var protocol = location.protocol;
if (!protocol) throw new Error("Can not read window protocol");
if (protocol === constants.a.FILE) return constants.a.FILE + "//";
if (protocol === constants.a.ABOUT) {
var parent = getParent(win);
return parent && canReadFromWindow(parent) ? getActualDomain(parent) : constants.a.ABOUT + "//";
}
var host = location.host;
if (!host) throw new Error("Can not read window host");
return protocol + "//" + host;
}
function getDomain(win) {
var domain = getActualDomain(win = win || window);
return domain && win.mockDomain && 0 === win.mockDomain.indexOf(constants.a.MOCK) ? win.mockDomain : domain;
}
function isActuallySameDomain(win) {
try {
if (win === window) return !0;
} catch (err) {}
try {
var desc = Object.getOwnPropertyDescriptor(win, "location");
if (desc && !1 === desc.enumerable) return !1;
} catch (err) {}
try {
if (isAboutProtocol(win) && canReadFromWindow(win)) return !0;
} catch (err) {}
try {
if (getActualDomain(win) === getActualDomain(window)) return !0;
} catch (err) {}
return !1;
}
function isAncestorParent(parent, child) {
if (!parent || !child) return !1;
var childParent = getParent(child);
return childParent ? childParent === parent : -1 !== function(win) {
var result = [];
try {
for (;win.parent !== win; ) {
result.push(win.parent);
win = win.parent;
}
} catch (err) {}
return result;
}(child).indexOf(parent);
}
function getFrames(win) {
var result = [], frames = void 0;
try {
frames = win.frames;
} catch (err) {
frames = win;
}
var len = void 0;
try {
len = frames.length;
} catch (err) {}
if (0 === len) return result;
if (len) {
for (var i = 0; i < len; i++) {
var frame = void 0;
try {
frame = frames[i];
} catch (err) {
continue;
}
result.push(frame);
}
return result;
}
for (var _i = 0; _i < 100; _i++) {
var _frame = void 0;
try {
_frame = frames[_i];
} catch (err) {
return result;
}
if (!_frame) return result;
result.push(_frame);
}
return result;
}
var iframeWindows = [], iframeFrames = [];
function getAncestor(win) {
return getOpener(win = win || window) || getParent(win) || void 0;
}
},
"./src/index.js": function(module, __webpack_exports__, __webpack_require__) {
Object.defineProperty(__webpack_exports__, "__esModule", {
value: !0
});
__webpack_require__.d({}, "WeakMap", function() {
return weakmap_CrossDomainSafeWeakMap;
});
var src_interface_namespaceObject = {};
__webpack_require__.d(src_interface_namespaceObject, "cleanUpWindow", function() {
return cleanUpWindow;
});
__webpack_require__.d(src_interface_namespaceObject, "Promise", function() {
return promise_ZalgoPromise;
});
__webpack_require__.d(src_interface_namespaceObject, "bridge", function() {
return bridge;
});
__webpack_require__.d(src_interface_namespaceObject, "init", function() {
return init;
});
__webpack_require__.d(src_interface_namespaceObject, "parent", function() {
return public_parent;
});
__webpack_require__.d(src_interface_namespaceObject, "send", function() {
return _send;
});
__webpack_require__.d(src_interface_namespaceObject, "request", function() {
return request;
});
__webpack_require__.d(src_interface_namespaceObject, "sendToParent", function() {
return sendToParent;
});
__webpack_require__.d(src_interface_namespaceObject, "client", function() {
return client;
});
__webpack_require__.d(src_interface_namespaceObject, "on", function() {
return _on;
});
__webpack_require__.d(src_interface_namespaceObject, "listen", function() {
return listen;
});
__webpack_require__.d(src_interface_namespaceObject, "once", function() {
return server_once;
});
__webpack_require__.d(src_interface_namespaceObject, "listener", function() {
return server_listener;
});
__webpack_require__.d(src_interface_namespaceObject, "CONFIG", function() {
return CONFIG;
});
__webpack_require__.d(src_interface_namespaceObject, "CONSTANTS", function() {
return constants_CONSTANTS;
});
__webpack_require__.d(src_interface_namespaceObject, "disable", function() {
return disable;
});
var src = __webpack_require__("./node_modules/cross-domain-utils/src/index.js");
function safeIndexOf(collection, item) {
for (var i = 0; i < collection.length; i++) try {
if (collection[i] === item) return i;
} catch (err) {}
return -1;
}
var _ALLOWED_POST_MESSAGE, defineProperty = Object.defineProperty, counter = Date.now() % 1e9, weakmap_CrossDomainSafeWeakMap = function() {
function CrossDomainSafeWeakMap() {
!function(instance, Constructor) {
if (!(instance instanceof CrossDomainSafeWeakMap)) throw new TypeError("Cannot call a class as a function");
}(this);
counter += 1;
this.name = "__weakmap_" + (1e9 * Math.random() >>> 0) + "__" + counter;
if (function() {
if ("undefined" == typeof WeakMap) return !1;
if (void 0 === Object.freeze) return !1;
try {
var testWeakMap = new WeakMap(), testKey = {};
Object.freeze(testKey);
testWeakMap.set(testKey, "__testvalue__");
return "__testvalue__" === testWeakMap.get(testKey);
} catch (err) {
return !1;
}
}()) try {
this.weakmap = new WeakMap();
} catch (err) {}
this.keys = [];
this.values = [];
}
CrossDomainSafeWeakMap.prototype._cleanupClosedWindows = function() {
for (var weakmap = this.weakmap, keys = this.keys, i = 0; i < keys.length; i++) {
var value = keys[i];
if (Object(src.isWindow)(value) && Object(src.isWindowClosed)(value)) {
if (weakmap) try {
weakmap.delete(value);
} catch (err) {}
keys.splice(i, 1);
this.values.splice(i, 1);
i -= 1;
}
}
};
CrossDomainSafeWeakMap.prototype.isSafeToReadWrite = function(key) {
if (Object(src.isWindow)(key)) return !1;
try {
key && key.self;
key && key[this.name];
} catch (err) {
return !1;
}
return !0;
};
CrossDomainSafeWeakMap.prototype.set = function(key, value) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
weakmap.set(key, value);
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) {
var name = this.name, entry = key[name];
entry && entry[0] === key ? entry[1] = value : defineProperty(key, name, {
value: [ key, value ],
writable: !0
});
} else {
this._cleanupClosedWindows();
var keys = this.keys, values = this.values, index = safeIndexOf(keys, key);
if (-1 === index) {
keys.push(key);
values.push(value);
} else values[index] = value;
}
};
CrossDomainSafeWeakMap.prototype.get = function(key) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
if (weakmap.has(key)) return weakmap.get(key);
} catch (err) {
delete this.weakmap;
}
if (!this.isSafeToReadWrite(key)) {
this._cleanupClosedWindows();
var index = safeIndexOf(this.keys, key);
if (-1 === index) return;
return this.values[index];
}
var entry = key[this.name];
if (entry && entry[0] === key) return entry[1];
};
CrossDomainSafeWeakMap.prototype.delete = function(key) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
weakmap.delete(key);
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) {
var entry = key[this.name];
entry && entry[0] === key && (entry[0] = entry[1] = void 0);
} else {
this._cleanupClosedWindows();
var keys = this.keys, index = safeIndexOf(keys, key);
if (-1 !== index) {
keys.splice(index, 1);
this.values.splice(index, 1);
}
}
};
CrossDomainSafeWeakMap.prototype.has = function(key) {
if (!key) throw new Error("WeakMap expected key");
var weakmap = this.weakmap;
if (weakmap) try {
if (weakmap.has(key)) return !0;
} catch (err) {
delete this.weakmap;
}
if (this.isSafeToReadWrite(key)) {
var entry = key[this.name];
return !(!entry || entry[0] !== key);
}
this._cleanupClosedWindows();
return -1 !== safeIndexOf(this.keys, key);
};
CrossDomainSafeWeakMap.prototype.getOrSet = function(key, getter) {
if (this.has(key)) return this.get(key);
var value = getter();
this.set(key, value);
return value;
};
return CrossDomainSafeWeakMap;
}(), constants_CONSTANTS = {
POST_MESSAGE_TYPE: {
REQUEST: "postrobot_message_request",
RESPONSE: "postrobot_message_response",
ACK: "postrobot_message_ack"
},
POST_MESSAGE_ACK: {
SUCCESS: "success",
ERROR: "error"
},
POST_MESSAGE_NAMES: {
METHOD: "postrobot_method",
HELLO: "postrobot_ready",
OPEN_TUNNEL: "postrobot_open_tunnel"
},
WINDOW_TYPES: {
FULLPAGE: "fullpage",
POPUP: "popup",
IFRAME: "iframe"
},
WINDOW_PROPS: {
POSTROBOT: "__postRobot__"
},
SERIALIZATION_TYPES: {
METHOD: "postrobot_method",
ERROR: "postrobot_error",
PROMISE: "postrobot_promise",
ZALGO_PROMISE: "postrobot_zalgo_promise",
REGEX: "regex"
},
SEND_STRATEGIES: {
POST_MESSAGE: "postrobot_post_message",
BRIDGE: "postrobot_bridge",
GLOBAL: "postrobot_global"
},
MOCK_PROTOCOL: "mock:",
FILE_PROTOCOL: "file:",
BRIDGE_NAME_PREFIX: "__postrobot_bridge__",
POSTROBOT_PROXY: "__postrobot_proxy__",
WILDCARD: "*"
}, POST_MESSAGE_NAMES = {
METHOD: "postrobot_method",
HELLO: "postrobot_hello",
OPEN_TUNNEL: "postrobot_open_tunnel"
}, CONFIG = (Object.keys(POST_MESSAGE_NAMES).map(function(key) {
return POST_MESSAGE_NAMES[key];
}), {
ALLOW_POSTMESSAGE_POPUP: !("__ALLOW_POSTMESSAGE_POPUP__" in window) || window.__ALLOW_POSTMESSAGE_POPUP__,
BRIDGE_TIMEOUT: 5e3,
CHILD_WINDOW_TIMEOUT: 5e3,
ACK_TIMEOUT: -1 !== window.navigator.userAgent.match(/MSIE/i) ? 1e4 : 2e3,
RES_TIMEOUT: -1,
ALLOWED_POST_MESSAGE_METHODS: (_ALLOWED_POST_MESSAGE = {}, _ALLOWED_POST_MESSAGE[constants_CONSTANTS.SEND_STRATEGIES.POST_MESSAGE] = !0,
_ALLOWED_POST_MESSAGE[constants_CONSTANTS.SEND_STRATEGIES.BRIDGE] = !0, _ALLOWED_POST_MESSAGE[constants_CONSTANTS.SEND_STRATEGIES.GLOBAL] = !0,
_ALLOWED_POST_MESSAGE),
ALLOW_SAME_ORIGIN: !1
});
0 === window.location.href.indexOf(constants_CONSTANTS.FILE_PROTOCOL) && (CONFIG.ALLOW_POSTMESSAGE_POPUP = !0);
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
return typeof obj;
} : function(obj) {
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
function stringifyError(err) {
var level = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 1;
if (level >= 3) return "stringifyError stack overflow";
try {
if (!err) return "<unknown error: " + Object.prototype.toString.call(err) + ">";
if ("string" == typeof err) return err;
if (err instanceof Error) {
var stack = err && err.stack, message = err && err.message;
if (stack && message) return -1 !== stack.indexOf(message) ? stack : message + "\n" + stack;
if (stack) return stack;
if (message) return message;
}
return "function" == typeof err.toString ? err.toString() : Object.prototype.toString.call(err);
} catch (newErr) {
return "Error while stringifying error: " + stringifyError(newErr, level + 1);
}
}
var once = function(method) {
if (!method) return method;
var called = !1;
return function() {
if (!called) {
called = !0;
return method.apply(this, arguments);
}
};
};
function util_noop() {}
function uniqueID() {
var chars = "0123456789abcdef";
return "xxxxxxxxxx".replace(/./g, function() {
return chars.charAt(Math.floor(Math.random() * chars.length));
});
}
function replaceObject(item, callback) {
var depth = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 1;
if (depth >= 100) throw new Error("Self-referential object passed, or object contained too many layers");
var newobj = void 0;
if ("object" !== (void 0 === item ? "undefined" : _typeof(item)) || null === item || Array.isArray(item)) {
if (!Array.isArray(item)) throw new TypeError("Invalid type: " + (void 0 === item ? "undefined" : _typeof(item)));
newobj = [];
} else newobj = {};
!function(item, callback) {
Array.isArray(item) ? function(item, callback) {
for (var i = 0; i < item.length; i++) callback(item[i], i);
}(item, callback) : "object" === (void 0 === item ? "undefined" : _typeof(item)) && null !== item && function(item, callback) {
for (var _key in item) item.hasOwnProperty(_key) && callback(item[_key], _key);
}(item, callback);
}(item, function(childItem, key) {
var result = callback(childItem, key);
void 0 !== result ? newobj[key] = result : "object" === (void 0 === childItem ? "undefined" : _typeof(childItem)) && null !== childItem ? newobj[key] = replaceObject(childItem, callback, depth + 1) : newobj[key] = childItem;
});
return newobj;
}
function isRegex(item) {
return "[object RegExp]" === Object.prototype.toString.call(item);
}
function utils_isPromise(item) {
try {
if (!item) return !1;
if ("undefined" != typeof Promise && item instanceof Promise) return !0;
if ("undefined" != typeof window && window.Window && item instanceof window.Window) return !1;
if ("undefined" != typeof window && window.constructor && item instanceof window.constructor) return !1;
if ("function" == typeof item.then) return !0;
} catch (err) {
return !1;
}
return !1;
}
function getGlobal() {
var glob = void 0;
if ("undefined" != typeof window) glob = window; else {
if ("undefined" == typeof window) throw new TypeError("Can not find global");
glob = window;
}
var zalgoGlobal = glob.__zalgopromise__ = glob.__zalgopromise__ || {};
zalgoGlobal.flushPromises = zalgoGlobal.flushPromises || [];
zalgoGlobal.activeCount = zalgoGlobal.activeCount || 0;
zalgoGlobal.possiblyUnhandledPromiseHandlers = zalgoGlobal.possiblyUnhandledPromiseHandlers || [];
zalgoGlobal.dispatchedErrors = zalgoGlobal.dispatchedErrors || [];
return zalgoGlobal;
}
var promise_ZalgoPromise = function() {
function ZalgoPromise(handler) {
var _this = this;
!function(instance, Constructor) {
if (!(instance instanceof ZalgoPromise)) throw new TypeError("Cannot call a class as a function");
}(this);
this.resolved = !1;
this.rejected = !1;
this.errorHandled = !1;
this.handlers = [];
if (handler) {
var _result = void 0, _error = void 0, resolved = !1, rejected = !1, isAsync = !1;
try {
handler(function(res) {
if (isAsync) _this.resolve(res); else {
resolved = !0;
_result = res;
}
}, function(err) {
if (isAsync) _this.reject(err); else {
rejected = !0;
_error = err;
}
});
} catch (err) {
this.reject(err);
return;
}
isAsync = !0;
resolved ? this.resolve(_result) : rejected && this.reject(_error);
}
}
ZalgoPromise.prototype.resolve = function(result) {
if (this.resolved || this.rejected) return this;
if (utils_isPromise(result)) throw new Error("Can not resolve promise with another promise");
this.resolved = !0;
this.value = result;
this.dispatch();
return this;
};
ZalgoPromise.prototype.reject = function(error) {
var _this2 = this;
if (this.resolved || this.rejected) return this;
if (utils_isPromise(error)) throw new Error("Can not reject promise with another promise");
if (!error) {
var _err = error && "function" == typeof error.toString ? error.toString() : Object.prototype.toString.call(error);
error = new Error("Expected reject to be called with Error, got " + _err);
}
this.rejected = !0;
this.error = error;
this.errorHandled || setTimeout(function() {
_this2.errorHandled || function(err, promise) {
if (-1 === getGlobal().dispatchedErrors.indexOf(err)) {
getGlobal().dispatchedErrors.push(err);
setTimeout(function() {
throw err;
}, 1);
for (var j = 0; j < getGlobal().possiblyUnhandledPromiseHandlers.length; j++) getGlobal().possiblyUnhandledPromiseHandlers[j](err, promise);
}
}(error, _this2);
}, 1);
this.dispatch();
return this;
};
ZalgoPromise.prototype.asyncReject = function(error) {
this.errorHandled = !0;
this.reject(error);
return this;
};
ZalgoPromise.prototype.dispatch = function() {
var _this3 = this, dispatching = this.dispatching, resolved = this.resolved, rejected = this.rejected, handlers = this.handlers;
if (!dispatching && (resolved || rejected)) {
this.dispatching = !0;
getGlobal().activeCount += 1;
for (var _loop = function(i) {
var _handlers$i = handlers[i], onSuccess = _handlers$i.onSuccess, onError = _handlers$i.onError, promise = _handlers$i.promise, result = void 0;
if (resolved) try {
result = onSuccess ? onSuccess(_this3.value) : _this3.value;
} catch (err) {
promise.reject(err);
return "continue";
} else if (rejected) {
if (!onError) {
promise.reject(_this3.error);
return "continue";
}
try {
result = onError(_this3.error);
} catch (err) {
promise.reject(err);
return "continue";
}
}
if (result instanceof ZalgoPromise && (result.resolved || result.rejected)) {
result.resolved ? promise.resolve(result.value) : promise.reject(result.error);
result.errorHandled = !0;
} else utils_isPromise(result) ? result instanceof ZalgoPromise && (result.resolved || result.rejected) ? result.resolved ? promise.resolve(result.value) : promise.reject(result.error) : result.then(function(res) {
promise.resolve(res);
}, function(err) {
promise.reject(err);
}) : promise.resolve(result);
}, i = 0; i < handlers.length; i++) _loop(i);
handlers.length = 0;
this.dispatching = !1;
getGlobal().activeCount -= 1;
0 === getGlobal().activeCount && ZalgoPromise.flushQueue();
}
};
ZalgoPromise.prototype.then = function(onSuccess, onError) {
if (onSuccess && "function" != typeof onSuccess && !onSuccess.call) throw new Error("Promise.then expected a function for success handler");
if (onError && "function" != typeof onError && !onError.call) throw new Error("Promise.then expected a function for error handler");
var promise = new ZalgoPromise();
this.handlers.push({
promise: promise,
onSuccess: onSuccess,
onError: onError
});
this.errorHandled = !0;
this.dispatch();
return promise;
};
ZalgoPromise.prototype.catch = function(onError) {
return this.then(void 0, onError);
};
ZalgoPromise.prototype.finally = function(onFinally) {
if (onFinally && "function" != typeof onFinally && !onFinally.ca