zoid
Version:
Cross domain components.
1,131 lines • 274 kB
JavaScript
!function(root, factory) {
"object" == typeof exports && "object" == typeof module ? module.exports = factory() : "function" == typeof define && define.amd ? define("zoid", [], factory) : "object" == typeof exports ? exports.zoid = factory() : root.zoid = factory();
}("undefined" != typeof self ? self : this, (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, {
enumerable: !0,
get: getter
});
};
__webpack_require__.r = function(exports) {
"undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
value: "Module"
});
Object.defineProperty(exports, "__esModule", {
value: !0
});
};
__webpack_require__.t = function(value, mode) {
1 & mode && (value = __webpack_require__(value));
if (8 & mode) return value;
if (4 & mode && "object" == typeof value && value && value.__esModule) return value;
var ns = Object.create(null);
__webpack_require__.r(ns);
Object.defineProperty(ns, "default", {
enumerable: !0,
value: value
});
if (2 & mode && "string" != typeof value) for (var key in value) __webpack_require__.d(ns, key, function(key) {
return value[key];
}.bind(null, key));
return ns;
};
__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 {}.hasOwnProperty.call(object, property);
};
__webpack_require__.p = "";
return __webpack_require__(__webpack_require__.s = 0);
}([ function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, "PopupOpenError", (function() {
return dom_PopupOpenError;
}));
__webpack_require__.d(__webpack_exports__, "create", (function() {
return component_create;
}));
__webpack_require__.d(__webpack_exports__, "destroy", (function() {
return component_destroy;
}));
__webpack_require__.d(__webpack_exports__, "destroyComponents", (function() {
return destroyComponents;
}));
__webpack_require__.d(__webpack_exports__, "destroyAll", (function() {
return destroyAll;
}));
__webpack_require__.d(__webpack_exports__, "PROP_TYPE", (function() {
return PROP_TYPE;
}));
__webpack_require__.d(__webpack_exports__, "PROP_SERIALIZATION", (function() {
return PROP_SERIALIZATION;
}));
__webpack_require__.d(__webpack_exports__, "CONTEXT", (function() {
return CONTEXT;
}));
__webpack_require__.d(__webpack_exports__, "EVENT", (function() {
return EVENT;
}));
function _setPrototypeOf(o, p) {
return (_setPrototypeOf = Object.setPrototypeOf || function(o, p) {
o.__proto__ = p;
return o;
})(o, p);
}
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass);
}
function _extends() {
return (_extends = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) ({}).hasOwnProperty.call(source, key) && (target[key] = source[key]);
}
return target;
}).apply(this, arguments);
}
function utils_isPromise(item) {
try {
if (!item) return !1;
if ("undefined" != typeof Promise && item instanceof Promise) return !0;
if ("undefined" != typeof window && "function" == typeof window.Window && item instanceof window.Window) return !1;
if ("undefined" != typeof window && "function" == typeof window.constructor && item instanceof window.constructor) return !1;
var _toString = {}.toString;
if (_toString) {
var name = _toString.call(item);
if ("[object Window]" === name || "[object global]" === name || "[object DOMWindow]" === name) return !1;
}
if ("function" == typeof item.then) return !0;
} catch (err) {
return !1;
}
return !1;
}
var dispatchedErrors = [];
var possiblyUnhandledPromiseHandlers = [];
var activeCount = 0;
var flushPromise;
function flushActive() {
if (!activeCount && flushPromise) {
var promise = flushPromise;
flushPromise = null;
promise.resolve();
}
}
function startActive() {
activeCount += 1;
}
function endActive() {
activeCount -= 1;
flushActive();
}
var promise_ZalgoPromise = function() {
function ZalgoPromise(handler) {
var _this = this;
this.resolved = void 0;
this.rejected = void 0;
this.errorHandled = void 0;
this.value = void 0;
this.error = void 0;
this.handlers = void 0;
this.dispatching = void 0;
this.stack = void 0;
this.resolved = !1;
this.rejected = !1;
this.errorHandled = !1;
this.handlers = [];
if (handler) {
var _result;
var _error;
var resolved = !1;
var rejected = !1;
var isAsync = !1;
startActive();
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) {
endActive();
this.reject(err);
return;
}
endActive();
isAsync = !0;
resolved ? this.resolve(_result) : rejected && this.reject(_error);
}
}
var _proto = ZalgoPromise.prototype;
_proto.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;
};
_proto.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() : {}.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 === dispatchedErrors.indexOf(err)) {
dispatchedErrors.push(err);
setTimeout((function() {
throw err;
}), 1);
for (var j = 0; j < possiblyUnhandledPromiseHandlers.length; j++) possiblyUnhandledPromiseHandlers[j](err, promise);
}
}(error, _this2);
}), 1);
this.dispatch();
return this;
};
_proto.asyncReject = function(error) {
this.errorHandled = !0;
this.reject(error);
return this;
};
_proto.dispatch = function() {
var resolved = this.resolved, rejected = this.rejected, handlers = this.handlers;
if (!this.dispatching && (resolved || rejected)) {
this.dispatching = !0;
startActive();
var chain = function(firstPromise, secondPromise) {
return firstPromise.then((function(res) {
secondPromise.resolve(res);
}), (function(err) {
secondPromise.reject(err);
}));
};
for (var i = 0; i < handlers.length; i++) {
var _handlers$i = handlers[i], onSuccess = _handlers$i.onSuccess, onError = _handlers$i.onError, promise = _handlers$i.promise;
var _result2 = void 0;
if (resolved) try {
_result2 = onSuccess ? onSuccess(this.value) : this.value;
} catch (err) {
promise.reject(err);
continue;
} else if (rejected) {
if (!onError) {
promise.reject(this.error);
continue;
}
try {
_result2 = onError(this.error);
} catch (err) {
promise.reject(err);
continue;
}
}
if (_result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected)) {
var promiseResult = _result2;
promiseResult.resolved ? promise.resolve(promiseResult.value) : promise.reject(promiseResult.error);
promiseResult.errorHandled = !0;
} else utils_isPromise(_result2) ? _result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected) ? _result2.resolved ? promise.resolve(_result2.value) : promise.reject(_result2.error) : chain(_result2, promise) : promise.resolve(_result2);
}
handlers.length = 0;
this.dispatching = !1;
endActive();
}
};
_proto.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;
};
_proto.catch = function(onError) {
return this.then(void 0, onError);
};
_proto.finally = function(onFinally) {
if (onFinally && "function" != typeof onFinally && !onFinally.call) throw new Error("Promise.finally expected a function");
return this.then((function(result) {
return ZalgoPromise.try(onFinally).then((function() {
return result;
}));
}), (function(err) {
return ZalgoPromise.try(onFinally).then((function() {
throw err;
}));
}));
};
_proto.timeout = function(time, err) {
var _this3 = this;
if (this.resolved || this.rejected) return this;
var timeout = setTimeout((function() {
_this3.resolved || _this3.rejected || _this3.reject(err || new Error("Promise timed out after " + time + "ms"));
}), time);
return this.then((function(result) {
clearTimeout(timeout);
return result;
}));
};
_proto.toPromise = function() {
if ("undefined" == typeof Promise) throw new TypeError("Could not find Promise");
return Promise.resolve(this);
};
_proto.lazy = function() {
this.errorHandled = !0;
return this;
};
ZalgoPromise.resolve = function(value) {
return value instanceof ZalgoPromise ? value : utils_isPromise(value) ? new ZalgoPromise((function(resolve, reject) {
return value.then(resolve, reject);
})) : (new ZalgoPromise).resolve(value);
};
ZalgoPromise.reject = function(error) {
return (new ZalgoPromise).reject(error);
};
ZalgoPromise.asyncReject = function(error) {
return (new ZalgoPromise).asyncReject(error);
};
ZalgoPromise.all = function(promises) {
var promise = new ZalgoPromise;
var count = promises.length;
var results = [].slice();
if (!count) {
promise.resolve(results);
return promise;
}
var chain = function(i, firstPromise, secondPromise) {
return firstPromise.then((function(res) {
results[i] = res;
0 == (count -= 1) && promise.resolve(results);
}), (function(err) {
secondPromise.reject(err);
}));
};
for (var i = 0; i < promises.length; i++) {
var prom = promises[i];
if (prom instanceof ZalgoPromise) {
if (prom.resolved) {
results[i] = prom.value;
count -= 1;
continue;
}
} else if (!utils_isPromise(prom)) {
results[i] = prom;
count -= 1;
continue;
}
chain(i, ZalgoPromise.resolve(prom), promise);
}
0 === count && promise.resolve(results);
return promise;
};
ZalgoPromise.hash = function(promises) {
var result = {};
var awaitPromises = [];
var _loop = function(key) {
if (promises.hasOwnProperty(key)) {
var value = promises[key];
utils_isPromise(value) ? awaitPromises.push(value.then((function(res) {
result[key] = res;
}))) : result[key] = value;
}
};
for (var key in promises) _loop(key);
return ZalgoPromise.all(awaitPromises).then((function() {
return result;
}));
};
ZalgoPromise.map = function(items, method) {
return ZalgoPromise.all(items.map(method));
};
ZalgoPromise.onPossiblyUnhandledException = function(handler) {
return function(handler) {
possiblyUnhandledPromiseHandlers.push(handler);
return {
cancel: function() {
possiblyUnhandledPromiseHandlers.splice(possiblyUnhandledPromiseHandlers.indexOf(handler), 1);
}
};
}(handler);
};
ZalgoPromise.try = function(method, context, args) {
if (method && "function" != typeof method && !method.call) throw new Error("Promise.try expected a function");
var result;
startActive();
try {
result = method.apply(context, args || []);
} catch (err) {
endActive();
return ZalgoPromise.reject(err);
}
endActive();
return ZalgoPromise.resolve(result);
};
ZalgoPromise.delay = function(_delay) {
return new ZalgoPromise((function(resolve) {
setTimeout(resolve, _delay);
}));
};
ZalgoPromise.isPromise = function(value) {
return !!(value && value instanceof ZalgoPromise) || utils_isPromise(value);
};
ZalgoPromise.flush = function() {
return function(Zalgo) {
var promise = flushPromise = flushPromise || new Zalgo;
flushActive();
return promise;
}(ZalgoPromise);
};
return ZalgoPromise;
}();
function isRegex(item) {
return "[object RegExp]" === {}.toString.call(item);
}
var WINDOW_TYPE = {
IFRAME: "iframe",
POPUP: "popup"
};
var IE_WIN_ACCESS_ERROR = "Call was rejected by callee.\r\n";
function getActualProtocol(win) {
void 0 === win && (win = window);
return win.location.protocol;
}
function getProtocol(win) {
void 0 === win && (win = window);
if (win.mockDomain) {
var protocol = win.mockDomain.split("//")[0];
if (protocol) return protocol;
}
return getActualProtocol(win);
}
function isAboutProtocol(win) {
void 0 === win && (win = window);
return "about:" === getProtocol(win);
}
function utils_getParent(win) {
void 0 === win && (win = window);
if (win) try {
if (win.parent && win.parent !== win) return win.parent;
} catch (err) {}
}
function getOpener(win) {
void 0 === win && (win = window);
if (win && !utils_getParent(win)) try {
return win.opener;
} catch (err) {}
}
function canReadFromWindow(win) {
try {
return !0;
} catch (err) {}
return !1;
}
function getActualDomain(win) {
void 0 === win && (win = window);
var location = win.location;
if (!location) throw new Error("Can not read window location");
var protocol = getActualProtocol(win);
if (!protocol) throw new Error("Can not read window protocol");
if ("file:" === protocol) return "file://";
if ("about:" === protocol) {
var parent = utils_getParent(win);
return parent && canReadFromWindow() ? getActualDomain(parent) : "about://";
}
var host = location.host;
if (!host) throw new Error("Can not read window host");
return protocol + "//" + host;
}
function getDomain(win) {
void 0 === win && (win = window);
var domain = getActualDomain(win);
return domain && win.mockDomain && 0 === win.mockDomain.indexOf("mock:") ? win.mockDomain : domain;
}
function isSameDomain(win) {
if (!function(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()) return !0;
} catch (err) {}
try {
if (function(win) {
void 0 === win && (win = window);
return "mock:" === getProtocol(win);
}(win) && canReadFromWindow()) return !0;
} catch (err) {}
try {
if (getActualDomain(win) === getActualDomain(window)) return !0;
} catch (err) {}
return !1;
}(win)) return !1;
try {
if (win === window) return !0;
if (isAboutProtocol(win) && canReadFromWindow()) return !0;
if (getDomain(window) === getDomain(win)) return !0;
} catch (err) {}
return !1;
}
function assertSameDomain(win) {
if (!isSameDomain(win)) throw new Error("Expected window to be same domain");
return win;
}
function isAncestorParent(parent, child) {
if (!parent || !child) return !1;
var childParent = utils_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 = [];
var frames;
try {
frames = win.frames;
} catch (err) {
frames = win;
}
var len;
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;
}
function getAllChildFrames(win) {
var result = [];
for (var _i3 = 0, _getFrames2 = getFrames(win); _i3 < _getFrames2.length; _i3++) {
var frame = _getFrames2[_i3];
result.push(frame);
for (var _i5 = 0, _getAllChildFrames2 = getAllChildFrames(frame); _i5 < _getAllChildFrames2.length; _i5++) result.push(_getAllChildFrames2[_i5]);
}
return result;
}
function getTop(win) {
void 0 === win && (win = window);
try {
if (win.top) return win.top;
} catch (err) {}
if (utils_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 = getAllChildFrames(win); _i7 < _getAllChildFrames4.length; _i7++) {
var frame = _getAllChildFrames4[_i7];
try {
if (frame.top) return frame.top;
} catch (err) {}
if (utils_getParent(frame) === frame) return frame;
}
}
function getAllFramesInWindow(win) {
var top = getTop(win);
if (!top) throw new Error("Can not determine top window");
var result = [].concat(getAllChildFrames(top), [ top ]);
-1 === result.indexOf(win) && (result = [].concat(result, [ win ], getAllChildFrames(win)));
return result;
}
var iframeWindows = [];
var iframeFrames = [];
function isWindowClosed(win, allowMock) {
void 0 === allowMock && (allowMock = !0);
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 && isSameDomain(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;
if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {
var parent = frame;
for (;parent.parentNode && parent.parentNode !== parent; ) parent = parent.parentNode;
if (!parent.host || !doc.documentElement.contains(parent.host)) return !0;
}
return !1;
}(frame)) return !0;
}
return !1;
}
function utils_getUserAgent(win) {
return (win = win || window).navigator.mockUserAgent || win.navigator.userAgent;
}
function getFrameByName(win, name) {
var winFrames = getFrames(win);
for (var _i9 = 0; _i9 < winFrames.length; _i9++) {
var childFrame = winFrames[_i9];
try {
if (isSameDomain(childFrame) && childFrame.name === name && -1 !== winFrames.indexOf(childFrame)) return childFrame;
} catch (err) {}
}
try {
if (-1 !== winFrames.indexOf(win.frames[name])) return win.frames[name];
} catch (err) {}
try {
if (-1 !== winFrames.indexOf(win[name])) return win[name];
} catch (err) {}
}
function isOpener(parent, child) {
return parent === getOpener(child);
}
function getAncestor(win) {
void 0 === win && (win = window);
return getOpener(win = win || window) || utils_getParent(win) || void 0;
}
function anyMatch(collection1, collection2) {
for (var _i17 = 0; _i17 < collection1.length; _i17++) {
var item1 = collection1[_i17];
for (var _i19 = 0; _i19 < collection2.length; _i19++) if (item1 === collection2[_i19]) return !0;
}
return !1;
}
function getDistanceFromTop(win) {
void 0 === win && (win = window);
var distance = 0;
var parent = win;
for (;parent; ) (parent = utils_getParent(parent)) && (distance += 1);
return distance;
}
function isSameTopWindow(win1, win2) {
var top1 = getTop(win1) || win1;
var top2 = getTop(win2) || win2;
try {
if (top1 && top2) return top1 === top2;
} catch (err) {}
var allFrames1 = getAllFramesInWindow(win1);
var allFrames2 = getAllFramesInWindow(win2);
if (anyMatch(allFrames1, allFrames2)) return !0;
var opener1 = getOpener(top1);
var opener2 = getOpener(top2);
return opener1 && anyMatch(getAllFramesInWindow(opener1), allFrames2) || opener2 && anyMatch(getAllFramesInWindow(opener2), allFrames1),
!1;
}
function matchDomain(pattern, origin) {
if ("string" == typeof pattern) {
if ("string" == typeof origin) return "*" === pattern || 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);
})));
}
function getDomainFromUrl(url) {
return url.match(/^(https?|mock|file):\/\//) ? url.split("/").slice(0, 3).join("/") : getDomain();
}
function onCloseWindow(win, callback, delay, maxtime) {
void 0 === delay && (delay = 1e3);
void 0 === maxtime && (maxtime = 1 / 0);
var timeout;
!function check() {
if (isWindowClosed(win)) {
timeout && clearTimeout(timeout);
return callback();
}
if (maxtime <= 0) clearTimeout(timeout); else {
maxtime -= delay;
timeout = setTimeout(check, delay);
}
}();
return {
cancel: function() {
timeout && clearTimeout(timeout);
}
};
}
function isWindow(obj) {
try {
if (obj === window) return !0;
} catch (err) {
if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;
}
try {
if ("[object Window]" === {}.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 {
if (obj && "__unlikely_value__" === obj.__cross_domain_utils_window_check__) return !1;
} catch (err) {
return !0;
}
try {
if ("postMessage" in obj && "self" in obj && "location" in obj) return !0;
} catch (err) {}
return !1;
}
function normalizeMockUrl(url) {
if (!(domain = getDomainFromUrl(url), 0 === domain.indexOf("mock:"))) return url;
var domain;
throw new Error("Mock urls not supported out of test mode");
}
function getFrameForWindow(win) {
if (isSameDomain(win)) return assertSameDomain(win).frameElement;
for (var _i21 = 0, _document$querySelect2 = document.querySelectorAll("iframe"); _i21 < _document$querySelect2.length; _i21++) {
var frame = _document$querySelect2[_i21];
if (frame && frame.contentWindow && frame.contentWindow === win) return frame;
}
}
function closeWindow(win) {
if (function(win) {
void 0 === win && (win = window);
return Boolean(utils_getParent(win));
}(win)) {
var frame = getFrameForWindow(win);
if (frame && frame.parentElement) {
frame.parentElement.removeChild(frame);
return;
}
}
try {
win.close();
} catch (err) {}
}
function util_safeIndexOf(collection, item) {
for (var i = 0; i < collection.length; i++) try {
if (collection[i] === item) return i;
} catch (err) {}
return -1;
}
var weakmap_CrossDomainSafeWeakMap = function() {
function CrossDomainSafeWeakMap() {
this.name = void 0;
this.weakmap = void 0;
this.keys = void 0;
this.values = void 0;
this.name = "__weakmap_" + (1e9 * Math.random() >>> 0) + "__";
if (function() {
if ("undefined" == typeof WeakMap) return !1;
if (void 0 === Object.freeze) return !1;
try {
var testWeakMap = new WeakMap;
var 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 = [];
}
var _proto = CrossDomainSafeWeakMap.prototype;
_proto._cleanupClosedWindows = function() {
var weakmap = this.weakmap;
var keys = this.keys;
for (var i = 0; i < keys.length; i++) {
var value = keys[i];
if (isWindow(value) && isWindowClosed(value)) {
if (weakmap) try {
weakmap.delete(value);
} catch (err) {}
keys.splice(i, 1);
this.values.splice(i, 1);
i -= 1;
}
}
};
_proto.isSafeToReadWrite = function(key) {
return !isWindow(key);
};
_proto.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)) try {
var name = this.name;
var entry = key[name];
entry && entry[0] === key ? entry[1] = value : Object.defineProperty(key, name, {
value: [ key, value ],
writable: !0
});
return;
} catch (err) {}
this._cleanupClosedWindows();
var keys = this.keys;
var values = this.values;
var index = util_safeIndexOf(keys, key);
if (-1 === index) {
keys.push(key);
values.push(value);
} else values[index] = value;
};
_proto.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)) try {
var entry = key[this.name];
return entry && entry[0] === key ? entry[1] : void 0;
} catch (err) {}
this._cleanupClosedWindows();
var index = util_safeIndexOf(this.keys, key);
if (-1 !== index) return this.values[index];
};
_proto.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)) try {
var entry = key[this.name];
entry && entry[0] === key && (entry[0] = entry[1] = void 0);
} catch (err) {}
this._cleanupClosedWindows();
var keys = this.keys;
var index = util_safeIndexOf(keys, key);
if (-1 !== index) {
keys.splice(index, 1);
this.values.splice(index, 1);
}
};
_proto.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)) try {
var entry = key[this.name];
return !(!entry || entry[0] !== key);
} catch (err) {}
this._cleanupClosedWindows();
return -1 !== util_safeIndexOf(this.keys, key);
};
_proto.getOrSet = function(key, getter) {
if (this.has(key)) return this.get(key);
var value = getter();
this.set(key, value);
return value;
};
return CrossDomainSafeWeakMap;
}();
function _getPrototypeOf(o) {
return (_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function(o) {
return o.__proto__ || Object.getPrototypeOf(o);
})(o);
}
function _isNativeReflectConstruct() {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
Date.prototype.toString.call(Reflect.construct(Date, [], (function() {})));
return !0;
} catch (e) {
return !1;
}
}
function construct_construct(Parent, args, Class) {
return (construct_construct = _isNativeReflectConstruct() ? Reflect.construct : function(Parent, args, Class) {
var a = [ null ];
a.push.apply(a, args);
var instance = new (Function.bind.apply(Parent, a));
Class && _setPrototypeOf(instance, Class.prototype);
return instance;
}).apply(null, arguments);
}
function wrapNativeSuper_wrapNativeSuper(Class) {
var _cache = "function" == typeof Map ? new Map : void 0;
return (wrapNativeSuper_wrapNativeSuper = function(Class) {
if (null === Class || !(fn = Class, -1 !== Function.toString.call(fn).indexOf("[native code]"))) return Class;
var fn;
if ("function" != typeof Class) throw new TypeError("Super expression must either be null or a function");
if (void 0 !== _cache) {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return construct_construct(Class, arguments, _getPrototypeOf(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: {
value: Wrapper,
enumerable: !1,
writable: !0,
configurable: !0
}
});
return _setPrototypeOf(Wrapper, Class);
})(Class);
}
function getFunctionName(fn) {
return fn.name || fn.__name__ || fn.displayName || "anonymous";
}
function setFunctionName(fn, name) {
try {
delete fn.name;
fn.name = name;
} catch (err) {}
fn.__name__ = fn.displayName = name;
return fn;
}
function base64encode(str) {
if ("function" == typeof btoa) return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (function(m, p1) {
return String.fromCharCode(parseInt(p1, 16));
}))).replace(/[=]/g, "");
if ("undefined" != typeof Buffer) return Buffer.from(str, "utf8").toString("base64").replace(/[=]/g, "");
throw new Error("Can not find window.btoa or Buffer");
}
function uniqueID() {
var chars = "0123456789abcdef";
return "uid_" + "xxxxxxxxxx".replace(/./g, (function() {
return chars.charAt(Math.floor(Math.random() * chars.length));
})) + "_" + base64encode((new Date).toISOString().slice(11, 19).replace("T", ".")).replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
}
var objectIDs;
function serializeArgs(args) {
try {
return JSON.stringify([].slice.call(args), (function(subkey, val) {
return "function" == typeof val ? "memoize[" + function(obj) {
objectIDs = objectIDs || new weakmap_CrossDomainSafeWeakMap;
if (null == obj || "object" != typeof obj && "function" != typeof obj) throw new Error("Invalid object");
var uid = objectIDs.get(obj);
if (!uid) {
uid = typeof obj + ":" + uniqueID();
objectIDs.set(obj, uid);
}
return uid;
}(val) + "]" : val;
}));
} catch (err) {
throw new Error("Arguments not serializable -- can not be used to memoize");
}
}
function getEmptyObject() {
return {};
}
var memoizeGlobalIndex = 0;
var memoizeGlobalIndexValidFrom = 0;
function memoize(method, options) {
void 0 === options && (options = {});
var _options$thisNamespac = options.thisNamespace, thisNamespace = void 0 !== _options$thisNamespac && _options$thisNamespac, cacheTime = options.time;
var simpleCache;
var thisCache;
var memoizeIndex = memoizeGlobalIndex;
memoizeGlobalIndex += 1;
var memoizedFunction = function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
if (memoizeIndex < memoizeGlobalIndexValidFrom) {
simpleCache = null;
thisCache = null;
memoizeIndex = memoizeGlobalIndex;
memoizeGlobalIndex += 1;
}
var cache;
cache = thisNamespace ? (thisCache = thisCache || new weakmap_CrossDomainSafeWeakMap).getOrSet(this, getEmptyObject) : simpleCache = simpleCache || {};
var cacheKey = serializeArgs(args);
var cacheResult = cache[cacheKey];
if (cacheResult && cacheTime && Date.now() - cacheResult.time < cacheTime) {
delete cache[cacheKey];
cacheResult = null;
}
if (cacheResult) return cacheResult.value;
var time = Date.now();
var value = method.apply(this, arguments);
cache[cacheKey] = {
time: time,
value: value
};
return value;
};
memoizedFunction.reset = function() {
simpleCache = null;
thisCache = null;
};
return setFunctionName(memoizedFunction, (options.name || getFunctionName(method)) + "::memoized");
}
memoize.clear = function() {
memoizeGlobalIndexValidFrom = memoizeGlobalIndex;
};
function memoizePromise(method) {
var cache = {};
function memoizedPromiseFunction() {
var _arguments = arguments, _this = this;
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2];
var key = serializeArgs(args);
if (cache.hasOwnProperty(key)) return cache[key];
cache[key] = promise_ZalgoPromise.try((function() {
return method.apply(_this, _arguments);
})).finally((function() {
delete cache[key];
}));
return cache[key];
}
memoizedPromiseFunction.reset = function() {
cache = {};
};
return setFunctionName(memoizedPromiseFunction, getFunctionName(method) + "::promiseMemoized");
}
function src_util_noop() {}
function once(method) {
var called = !1;
return setFunctionName((function() {
if (!called) {
called = !0;
return method.apply(this, arguments);
}
}), getFunctionName(method) + "::once");
}
function stringifyError(err, level) {
void 0 === level && (level = 1);
if (level >= 3) return "stringifyError stack overflow";
try {
if (!err) return "<unknown error: " + {}.toString.call(err) + ">";
if ("string" == typeof err) return err;
if (err instanceof Error) {
var stack = err && err.stack;
var 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 err && err.toString && "function" == typeof err.toString ? err.toString() : {}.toString.call(err);
} catch (newErr) {
return "Error while stringifying error: " + stringifyError(newErr, level + 1);
}
}
function stringify(item) {
return "string" == typeof item ? item : item && item.toString && "function" == typeof item.toString ? item.toString() : {}.toString.call(item);
}
function extend(obj, source) {
if (!sour