@simplepay-ai/widget
Version:
SimplePay Payment Widget
1,403 lines • 809 kB
JavaScript
import { c as commonjsGlobal, g as getDefaultExportFromCjs, p as process$1, a as global } from "./main-oDQ_krE7.js";
import { t } from "./browser-C8EeK1xj.js";
var browserPonyfill = { exports: {} };
(function(module, exports) {
var __global__ = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || typeof commonjsGlobal !== "undefined" && commonjsGlobal;
var __globalThis__ = function() {
function F2() {
this.fetch = false;
this.DOMException = __global__.DOMException;
}
F2.prototype = __global__;
return new F2();
}();
(function(globalThis2) {
(function(exports2) {
var g2 = typeof globalThis2 !== "undefined" && globalThis2 || typeof self !== "undefined" && self || // eslint-disable-next-line no-undef
typeof commonjsGlobal !== "undefined" && commonjsGlobal || {};
var support = {
searchParams: "URLSearchParams" in g2,
iterable: "Symbol" in g2 && "iterator" in Symbol,
blob: "FileReader" in g2 && "Blob" in g2 && function() {
try {
new Blob();
return true;
} catch (e7) {
return false;
}
}(),
formData: "FormData" in g2,
arrayBuffer: "ArrayBuffer" in g2
};
function isDataView(obj) {
return obj && DataView.prototype.isPrototypeOf(obj);
}
if (support.arrayBuffer) {
var viewClasses = [
"[object Int8Array]",
"[object Uint8Array]",
"[object Uint8ClampedArray]",
"[object Int16Array]",
"[object Uint16Array]",
"[object Int32Array]",
"[object Uint32Array]",
"[object Float32Array]",
"[object Float64Array]"
];
var isArrayBufferView = ArrayBuffer.isView || function(obj) {
return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
};
}
function normalizeName(name) {
if (typeof name !== "string") {
name = String(name);
}
if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
throw new TypeError('Invalid character in header field name: "' + name + '"');
}
return name.toLowerCase();
}
function normalizeValue(value2) {
if (typeof value2 !== "string") {
value2 = String(value2);
}
return value2;
}
function iteratorFor(items) {
var iterator = {
next: function() {
var value2 = items.shift();
return { done: value2 === void 0, value: value2 };
}
};
if (support.iterable) {
iterator[Symbol.iterator] = function() {
return iterator;
};
}
return iterator;
}
function Headers(headers) {
this.map = {};
if (headers instanceof Headers) {
headers.forEach(function(value2, name) {
this.append(name, value2);
}, this);
} else if (Array.isArray(headers)) {
headers.forEach(function(header) {
if (header.length != 2) {
throw new TypeError("Headers constructor: expected name/value pair to be length 2, found" + header.length);
}
this.append(header[0], header[1]);
}, this);
} else if (headers) {
Object.getOwnPropertyNames(headers).forEach(function(name) {
this.append(name, headers[name]);
}, this);
}
}
Headers.prototype.append = function(name, value2) {
name = normalizeName(name);
value2 = normalizeValue(value2);
var oldValue = this.map[name];
this.map[name] = oldValue ? oldValue + ", " + value2 : value2;
};
Headers.prototype["delete"] = function(name) {
delete this.map[normalizeName(name)];
};
Headers.prototype.get = function(name) {
name = normalizeName(name);
return this.has(name) ? this.map[name] : null;
};
Headers.prototype.has = function(name) {
return this.map.hasOwnProperty(normalizeName(name));
};
Headers.prototype.set = function(name, value2) {
this.map[normalizeName(name)] = normalizeValue(value2);
};
Headers.prototype.forEach = function(callback, thisArg) {
for (var name in this.map) {
if (this.map.hasOwnProperty(name)) {
callback.call(thisArg, this.map[name], name, this);
}
}
};
Headers.prototype.keys = function() {
var items = [];
this.forEach(function(value2, name) {
items.push(name);
});
return iteratorFor(items);
};
Headers.prototype.values = function() {
var items = [];
this.forEach(function(value2) {
items.push(value2);
});
return iteratorFor(items);
};
Headers.prototype.entries = function() {
var items = [];
this.forEach(function(value2, name) {
items.push([name, value2]);
});
return iteratorFor(items);
};
if (support.iterable) {
Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
}
function consumed(body) {
if (body._noBody) return;
if (body.bodyUsed) {
return Promise.reject(new TypeError("Already read"));
}
body.bodyUsed = true;
}
function fileReaderReady(reader) {
return new Promise(function(resolve, reject) {
reader.onload = function() {
resolve(reader.result);
};
reader.onerror = function() {
reject(reader.error);
};
});
}
function readBlobAsArrayBuffer(blob) {
var reader = new FileReader();
var promise = fileReaderReady(reader);
reader.readAsArrayBuffer(blob);
return promise;
}
function readBlobAsText(blob) {
var reader = new FileReader();
var promise = fileReaderReady(reader);
var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
var encoding = match ? match[1] : "utf-8";
reader.readAsText(blob, encoding);
return promise;
}
function readArrayBufferAsText(buf) {
var view = new Uint8Array(buf);
var chars2 = new Array(view.length);
for (var i = 0; i < view.length; i++) {
chars2[i] = String.fromCharCode(view[i]);
}
return chars2.join("");
}
function bufferClone(buf) {
if (buf.slice) {
return buf.slice(0);
} else {
var view = new Uint8Array(buf.byteLength);
view.set(new Uint8Array(buf));
return view.buffer;
}
}
function Body() {
this.bodyUsed = false;
this._initBody = function(body) {
this.bodyUsed = this.bodyUsed;
this._bodyInit = body;
if (!body) {
this._noBody = true;
this._bodyText = "";
} else if (typeof body === "string") {
this._bodyText = body;
} else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
this._bodyBlob = body;
} else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
this._bodyFormData = body;
} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
this._bodyText = body.toString();
} else if (support.arrayBuffer && support.blob && isDataView(body)) {
this._bodyArrayBuffer = bufferClone(body.buffer);
this._bodyInit = new Blob([this._bodyArrayBuffer]);
} else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
this._bodyArrayBuffer = bufferClone(body);
} else {
this._bodyText = body = Object.prototype.toString.call(body);
}
if (!this.headers.get("content-type")) {
if (typeof body === "string") {
this.headers.set("content-type", "text/plain;charset=UTF-8");
} else if (this._bodyBlob && this._bodyBlob.type) {
this.headers.set("content-type", this._bodyBlob.type);
} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
}
}
};
if (support.blob) {
this.blob = function() {
var rejected = consumed(this);
if (rejected) {
return rejected;
}
if (this._bodyBlob) {
return Promise.resolve(this._bodyBlob);
} else if (this._bodyArrayBuffer) {
return Promise.resolve(new Blob([this._bodyArrayBuffer]));
} else if (this._bodyFormData) {
throw new Error("could not read FormData body as blob");
} else {
return Promise.resolve(new Blob([this._bodyText]));
}
};
}
this.arrayBuffer = function() {
if (this._bodyArrayBuffer) {
var isConsumed = consumed(this);
if (isConsumed) {
return isConsumed;
} else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
return Promise.resolve(
this._bodyArrayBuffer.buffer.slice(
this._bodyArrayBuffer.byteOffset,
this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
)
);
} else {
return Promise.resolve(this._bodyArrayBuffer);
}
} else if (support.blob) {
return this.blob().then(readBlobAsArrayBuffer);
} else {
throw new Error("could not read as ArrayBuffer");
}
};
this.text = function() {
var rejected = consumed(this);
if (rejected) {
return rejected;
}
if (this._bodyBlob) {
return readBlobAsText(this._bodyBlob);
} else if (this._bodyArrayBuffer) {
return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
} else if (this._bodyFormData) {
throw new Error("could not read FormData body as text");
} else {
return Promise.resolve(this._bodyText);
}
};
if (support.formData) {
this.formData = function() {
return this.text().then(decode2);
};
}
this.json = function() {
return this.text().then(JSON.parse);
};
return this;
}
var methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
function normalizeMethod(method) {
var upcased = method.toUpperCase();
return methods.indexOf(upcased) > -1 ? upcased : method;
}
function Request2(input, options) {
if (!(this instanceof Request2)) {
throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
}
options = options || {};
var body = options.body;
if (input instanceof Request2) {
if (input.bodyUsed) {
throw new TypeError("Already read");
}
this.url = input.url;
this.credentials = input.credentials;
if (!options.headers) {
this.headers = new Headers(input.headers);
}
this.method = input.method;
this.mode = input.mode;
this.signal = input.signal;
if (!body && input._bodyInit != null) {
body = input._bodyInit;
input.bodyUsed = true;
}
} else {
this.url = String(input);
}
this.credentials = options.credentials || this.credentials || "same-origin";
if (options.headers || !this.headers) {
this.headers = new Headers(options.headers);
}
this.method = normalizeMethod(options.method || this.method || "GET");
this.mode = options.mode || this.mode || null;
this.signal = options.signal || this.signal || function() {
if ("AbortController" in g2) {
var ctrl = new AbortController();
return ctrl.signal;
}
}();
this.referrer = null;
if ((this.method === "GET" || this.method === "HEAD") && body) {
throw new TypeError("Body not allowed for GET or HEAD requests");
}
this._initBody(body);
if (this.method === "GET" || this.method === "HEAD") {
if (options.cache === "no-store" || options.cache === "no-cache") {
var reParamSearch = /([?&])_=[^&]*/;
if (reParamSearch.test(this.url)) {
this.url = this.url.replace(reParamSearch, "$1_=" + (/* @__PURE__ */ new Date()).getTime());
} else {
var reQueryString = /\?/;
this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (/* @__PURE__ */ new Date()).getTime();
}
}
}
}
Request2.prototype.clone = function() {
return new Request2(this, { body: this._bodyInit });
};
function decode2(body) {
var form = new FormData();
body.trim().split("&").forEach(function(bytes) {
if (bytes) {
var split = bytes.split("=");
var name = split.shift().replace(/\+/g, " ");
var value2 = split.join("=").replace(/\+/g, " ");
form.append(decodeURIComponent(name), decodeURIComponent(value2));
}
});
return form;
}
function parseHeaders(rawHeaders) {
var headers = new Headers();
var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
preProcessedHeaders.split("\r").map(function(header) {
return header.indexOf("\n") === 0 ? header.substr(1, header.length) : header;
}).forEach(function(line) {
var parts2 = line.split(":");
var key = parts2.shift().trim();
if (key) {
var value2 = parts2.join(":").trim();
try {
headers.append(key, value2);
} catch (error) {
console.warn("Response " + error.message);
}
}
});
return headers;
}
Body.call(Request2.prototype);
function Response(bodyInit, options) {
if (!(this instanceof Response)) {
throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
}
if (!options) {
options = {};
}
this.type = "default";
this.status = options.status === void 0 ? 200 : options.status;
if (this.status < 200 || this.status > 599) {
throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
}
this.ok = this.status >= 200 && this.status < 300;
this.statusText = options.statusText === void 0 ? "" : "" + options.statusText;
this.headers = new Headers(options.headers);
this.url = options.url || "";
this._initBody(bodyInit);
}
Body.call(Response.prototype);
Response.prototype.clone = function() {
return new Response(this._bodyInit, {
status: this.status,
statusText: this.statusText,
headers: new Headers(this.headers),
url: this.url
});
};
Response.error = function() {
var response = new Response(null, { status: 200, statusText: "" });
response.ok = false;
response.status = 0;
response.type = "error";
return response;
};
var redirectStatuses = [301, 302, 303, 307, 308];
Response.redirect = function(url2, status) {
if (redirectStatuses.indexOf(status) === -1) {
throw new RangeError("Invalid status code");
}
return new Response(null, { status, headers: { location: url2 } });
};
exports2.DOMException = g2.DOMException;
try {
new exports2.DOMException();
} catch (err) {
exports2.DOMException = function(message, name) {
this.message = message;
this.name = name;
var error = Error(message);
this.stack = error.stack;
};
exports2.DOMException.prototype = Object.create(Error.prototype);
exports2.DOMException.prototype.constructor = exports2.DOMException;
}
function fetch2(input, init) {
return new Promise(function(resolve, reject) {
var request = new Request2(input, init);
if (request.signal && request.signal.aborted) {
return reject(new exports2.DOMException("Aborted", "AbortError"));
}
var xhr = new XMLHttpRequest();
function abortXhr() {
xhr.abort();
}
xhr.onload = function() {
var options = {
statusText: xhr.statusText,
headers: parseHeaders(xhr.getAllResponseHeaders() || "")
};
if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
options.status = 200;
} else {
options.status = xhr.status;
}
options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
var body = "response" in xhr ? xhr.response : xhr.responseText;
setTimeout(function() {
resolve(new Response(body, options));
}, 0);
};
xhr.onerror = function() {
setTimeout(function() {
reject(new TypeError("Network request failed"));
}, 0);
};
xhr.ontimeout = function() {
setTimeout(function() {
reject(new TypeError("Network request timed out"));
}, 0);
};
xhr.onabort = function() {
setTimeout(function() {
reject(new exports2.DOMException("Aborted", "AbortError"));
}, 0);
};
function fixUrl(url2) {
try {
return url2 === "" && g2.location.href ? g2.location.href : url2;
} catch (e7) {
return url2;
}
}
xhr.open(request.method, fixUrl(request.url), true);
if (request.credentials === "include") {
xhr.withCredentials = true;
} else if (request.credentials === "omit") {
xhr.withCredentials = false;
}
if ("responseType" in xhr) {
if (support.blob) {
xhr.responseType = "blob";
} else if (support.arrayBuffer) {
xhr.responseType = "arraybuffer";
}
}
if (init && typeof init.headers === "object" && !(init.headers instanceof Headers || g2.Headers && init.headers instanceof g2.Headers)) {
var names = [];
Object.getOwnPropertyNames(init.headers).forEach(function(name) {
names.push(normalizeName(name));
xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
});
request.headers.forEach(function(value2, name) {
if (names.indexOf(name) === -1) {
xhr.setRequestHeader(name, value2);
}
});
} else {
request.headers.forEach(function(value2, name) {
xhr.setRequestHeader(name, value2);
});
}
if (request.signal) {
request.signal.addEventListener("abort", abortXhr);
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
request.signal.removeEventListener("abort", abortXhr);
}
};
}
xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
});
}
fetch2.polyfill = true;
if (!g2.fetch) {
g2.fetch = fetch2;
g2.Headers = Headers;
g2.Request = Request2;
g2.Response = Response;
}
exports2.Headers = Headers;
exports2.Request = Request2;
exports2.Response = Response;
exports2.fetch = fetch2;
return exports2;
})({});
})(__globalThis__);
__globalThis__.fetch.ponyfill = true;
delete __globalThis__.fetch.polyfill;
var ctx = __global__.fetch ? __global__ : __globalThis__;
exports = ctx.fetch;
exports.default = ctx.fetch;
exports.fetch = ctx.fetch;
exports.Headers = ctx.Headers;
exports.Request = ctx.Request;
exports.Response = ctx.Response;
module.exports = exports;
})(browserPonyfill, browserPonyfill.exports);
var browserPonyfillExports = browserPonyfill.exports;
const e = /* @__PURE__ */ getDefaultExportFromCjs(browserPonyfillExports);
var eventemitter2 = { exports: {} };
(function(module, exports) {
!function(undefined$1) {
var hasOwnProperty = Object.hasOwnProperty;
var isArray = Array.isArray ? Array.isArray : function _isArray(obj) {
return Object.prototype.toString.call(obj) === "[object Array]";
};
var defaultMaxListeners = 10;
var nextTickSupported = typeof process$1 == "object" && typeof process$1.nextTick == "function";
var symbolsSupported = typeof Symbol === "function";
var reflectSupported = typeof Reflect === "object";
var setImmediateSupported = typeof setImmediate === "function";
var _setImmediate = setImmediateSupported ? setImmediate : setTimeout;
var ownKeys = symbolsSupported ? reflectSupported && typeof Reflect.ownKeys === "function" ? Reflect.ownKeys : function(obj) {
var arr = Object.getOwnPropertyNames(obj);
arr.push.apply(arr, Object.getOwnPropertySymbols(obj));
return arr;
} : Object.keys;
function init() {
this._events = {};
if (this._conf) {
configure.call(this, this._conf);
}
}
function configure(conf) {
if (conf) {
this._conf = conf;
conf.delimiter && (this.delimiter = conf.delimiter);
if (conf.maxListeners !== undefined$1) {
this._maxListeners = conf.maxListeners;
}
conf.wildcard && (this.wildcard = conf.wildcard);
conf.newListener && (this._newListener = conf.newListener);
conf.removeListener && (this._removeListener = conf.removeListener);
conf.verboseMemoryLeak && (this.verboseMemoryLeak = conf.verboseMemoryLeak);
conf.ignoreErrors && (this.ignoreErrors = conf.ignoreErrors);
if (this.wildcard) {
this.listenerTree = {};
}
}
}
function logPossibleMemoryLeak(count, eventName) {
var errorMsg = "(node) warning: possible EventEmitter memory leak detected. " + count + " listeners added. Use emitter.setMaxListeners() to increase limit.";
if (this.verboseMemoryLeak) {
errorMsg += " Event name: " + eventName + ".";
}
if (typeof process$1 !== "undefined" && process$1.emitWarning) {
var e7 = new Error(errorMsg);
e7.name = "MaxListenersExceededWarning";
e7.emitter = this;
e7.count = count;
process$1.emitWarning(e7);
} else {
console.error(errorMsg);
if (console.trace) {
console.trace();
}
}
}
var toArray2 = function(a2, b2, c2) {
var n2 = arguments.length;
switch (n2) {
case 0:
return [];
case 1:
return [a2];
case 2:
return [a2, b2];
case 3:
return [a2, b2, c2];
default:
var arr = new Array(n2);
while (n2--) {
arr[n2] = arguments[n2];
}
return arr;
}
};
function toObject(keys, values) {
var obj = {};
var key;
var len = keys.length;
var valuesCount = 0;
for (var i = 0; i < len; i++) {
key = keys[i];
obj[key] = i < valuesCount ? values[i] : undefined$1;
}
return obj;
}
function TargetObserver(emitter, target, options) {
this._emitter = emitter;
this._target = target;
this._listeners = {};
this._listenersCount = 0;
var on2, off;
if (options.on || options.off) {
on2 = options.on;
off = options.off;
}
if (target.addEventListener) {
on2 = target.addEventListener;
off = target.removeEventListener;
} else if (target.addListener) {
on2 = target.addListener;
off = target.removeListener;
} else if (target.on) {
on2 = target.on;
off = target.off;
}
if (!on2 && !off) {
throw Error("target does not implement any known event API");
}
if (typeof on2 !== "function") {
throw TypeError("on method must be a function");
}
if (typeof off !== "function") {
throw TypeError("off method must be a function");
}
this._on = on2;
this._off = off;
var _observers = emitter._observers;
if (_observers) {
_observers.push(this);
} else {
emitter._observers = [this];
}
}
Object.assign(TargetObserver.prototype, {
subscribe: function(event, localEvent, reducer) {
var observer = this;
var target = this._target;
var emitter = this._emitter;
var listeners = this._listeners;
var handler = function() {
var args = toArray2.apply(null, arguments);
var eventObj = {
data: args,
name: localEvent,
original: event
};
if (reducer) {
var result = reducer.call(target, eventObj);
if (result !== false) {
emitter.emit.apply(emitter, [eventObj.name].concat(args));
}
return;
}
emitter.emit.apply(emitter, [localEvent].concat(args));
};
if (listeners[event]) {
throw Error("Event '" + event + "' is already listening");
}
this._listenersCount++;
if (emitter._newListener && emitter._removeListener && !observer._onNewListener) {
this._onNewListener = function(_event) {
if (_event === localEvent && listeners[event] === null) {
listeners[event] = handler;
observer._on.call(target, event, handler);
}
};
emitter.on("newListener", this._onNewListener);
this._onRemoveListener = function(_event) {
if (_event === localEvent && !emitter.hasListeners(_event) && listeners[event]) {
listeners[event] = null;
observer._off.call(target, event, handler);
}
};
listeners[event] = null;
emitter.on("removeListener", this._onRemoveListener);
} else {
listeners[event] = handler;
observer._on.call(target, event, handler);
}
},
unsubscribe: function(event) {
var observer = this;
var listeners = this._listeners;
var emitter = this._emitter;
var handler;
var events;
var off = this._off;
var target = this._target;
var i;
if (event && typeof event !== "string") {
throw TypeError("event must be a string");
}
function clearRefs() {
if (observer._onNewListener) {
emitter.off("newListener", observer._onNewListener);
emitter.off("removeListener", observer._onRemoveListener);
observer._onNewListener = null;
observer._onRemoveListener = null;
}
var index = findTargetIndex.call(emitter, observer);
emitter._observers.splice(index, 1);
}
if (event) {
handler = listeners[event];
if (!handler) return;
off.call(target, event, handler);
delete listeners[event];
if (!--this._listenersCount) {
clearRefs();
}
} else {
events = ownKeys(listeners);
i = events.length;
while (i-- > 0) {
event = events[i];
off.call(target, event, listeners[event]);
}
this._listeners = {};
this._listenersCount = 0;
clearRefs();
}
}
});
function resolveOptions(options, schema, reducers, allowUnknown) {
var computedOptions = Object.assign({}, schema);
if (!options) return computedOptions;
if (typeof options !== "object") {
throw TypeError("options must be an object");
}
var keys = Object.keys(options);
var length = keys.length;
var option, value2;
var reducer;
function reject(reason) {
throw Error('Invalid "' + option + '" option value' + (reason ? ". Reason: " + reason : ""));
}
for (var i = 0; i < length; i++) {
option = keys[i];
if (!hasOwnProperty.call(schema, option)) {
throw Error('Unknown "' + option + '" option');
}
value2 = options[option];
if (value2 !== undefined$1) {
reducer = reducers[option];
computedOptions[option] = reducer ? reducer(value2, reject) : value2;
}
}
return computedOptions;
}
function constructorReducer(value2, reject) {
if (typeof value2 !== "function" || !value2.hasOwnProperty("prototype")) {
reject("value must be a constructor");
}
return value2;
}
function makeTypeReducer(types) {
var message = "value must be type of " + types.join("|");
var len = types.length;
var firstType = types[0];
var secondType = types[1];
if (len === 1) {
return function(v2, reject) {
if (typeof v2 === firstType) {
return v2;
}
reject(message);
};
}
if (len === 2) {
return function(v2, reject) {
var kind = typeof v2;
if (kind === firstType || kind === secondType) return v2;
reject(message);
};
}
return function(v2, reject) {
var kind = typeof v2;
var i = len;
while (i-- > 0) {
if (kind === types[i]) return v2;
}
reject(message);
};
}
var functionReducer = makeTypeReducer(["function"]);
var objectFunctionReducer = makeTypeReducer(["object", "function"]);
function makeCancelablePromise(Promise2, executor, options) {
var isCancelable;
var callbacks;
var timer = 0;
var subscriptionClosed;
var promise = new Promise2(function(resolve, reject, onCancel) {
options = resolveOptions(options, {
timeout: 0,
overload: false
}, {
timeout: function(value2, reject2) {
value2 *= 1;
if (typeof value2 !== "number" || value2 < 0 || !Number.isFinite(value2)) {
reject2("timeout must be a positive number");
}
return value2;
}
});
isCancelable = !options.overload && typeof Promise2.prototype.cancel === "function" && typeof onCancel === "function";
function cleanup() {
if (callbacks) {
callbacks = null;
}
if (timer) {
clearTimeout(timer);
timer = 0;
}
}
var _resolve = function(value2) {
cleanup();
resolve(value2);
};
var _reject = function(err) {
cleanup();
reject(err);
};
if (isCancelable) {
executor(_resolve, _reject, onCancel);
} else {
callbacks = [function(reason) {
_reject(reason || Error("canceled"));
}];
executor(_resolve, _reject, function(cb) {
if (subscriptionClosed) {
throw Error("Unable to subscribe on cancel event asynchronously");
}
if (typeof cb !== "function") {
throw TypeError("onCancel callback must be a function");
}
callbacks.push(cb);
});
subscriptionClosed = true;
}
if (options.timeout > 0) {
timer = setTimeout(function() {
var reason = Error("timeout");
reason.code = "ETIMEDOUT";
timer = 0;
promise.cancel(reason);
reject(reason);
}, options.timeout);
}
});
if (!isCancelable) {
promise.cancel = function(reason) {
if (!callbacks) {
return;
}
var length = callbacks.length;
for (var i = 1; i < length; i++) {
callbacks[i](reason);
}
callbacks[0](reason);
callbacks = null;
};
}
return promise;
}
function findTargetIndex(observer) {
var observers = this._observers;
if (!observers) {
return -1;
}
var len = observers.length;
for (var i = 0; i < len; i++) {
if (observers[i]._target === observer) return i;
}
return -1;
}
function searchListenerTree(handlers, type, tree, i, typeLength) {
if (!tree) {
return null;
}
if (i === 0) {
var kind = typeof type;
if (kind === "string") {
var ns2, n2, l2 = 0, j2 = 0, delimiter = this.delimiter, dl2 = delimiter.length;
if ((n2 = type.indexOf(delimiter)) !== -1) {
ns2 = new Array(5);
do {
ns2[l2++] = type.slice(j2, n2);
j2 = n2 + dl2;
} while ((n2 = type.indexOf(delimiter, j2)) !== -1);
ns2[l2++] = type.slice(j2);
type = ns2;
typeLength = l2;
} else {
type = [type];
typeLength = 1;
}
} else if (kind === "object") {
typeLength = type.length;
} else {
type = [type];
typeLength = 1;
}
}
var listeners = null, branch, xTree, xxTree, isolatedBranch, endReached, currentType = type[i], nextType = type[i + 1], branches, _listeners;
if (i === typeLength) {
if (tree._listeners) {
if (typeof tree._listeners === "function") {
handlers && handlers.push(tree._listeners);
listeners = [tree];
} else {
handlers && handlers.push.apply(handlers, tree._listeners);
listeners = [tree];
}
}
} else {
if (currentType === "*") {
branches = ownKeys(tree);
n2 = branches.length;
while (n2-- > 0) {
branch = branches[n2];
if (branch !== "_listeners") {
_listeners = searchListenerTree(handlers, type, tree[branch], i + 1, typeLength);
if (_listeners) {
if (listeners) {
listeners.push.apply(listeners, _listeners);
} else {
listeners = _listeners;
}
}
}
}
return listeners;
} else if (currentType === "**") {
endReached = i + 1 === typeLength || i + 2 === typeLength && nextType === "*";
if (endReached && tree._listeners) {
listeners = searchListenerTree(handlers, type, tree, typeLength, typeLength);
}
branches = ownKeys(tree);
n2 = branches.length;
while (n2-- > 0) {
branch = branches[n2];
if (branch !== "_listeners") {
if (branch === "*" || branch === "**") {
if (tree[branch]._listeners && !endReached) {
_listeners = searchListenerTree(handlers, type, tree[branch], typeLength, typeLength);
if (_listeners) {
if (listeners) {
listeners.push.apply(listeners, _listeners);
} else {
listeners = _listeners;
}
}
}
_listeners = searchListenerTree(handlers, type, tree[branch], i, typeLength);
} else if (branch === nextType) {
_listeners = searchListenerTree(handlers, type, tree[branch], i + 2, typeLength);
} else {
_listeners = searchListenerTree(handlers, type, tree[branch], i, typeLength);
}
if (_listeners) {
if (listeners) {
listeners.push.apply(listeners, _listeners);
} else {
listeners = _listeners;
}
}
}
}
return listeners;
} else if (tree[currentType]) {
listeners = searchListenerTree(handlers, type, tree[currentType], i + 1, typeLength);
}
}
xTree = tree["*"];
if (xTree) {
searchListenerTree(handlers, type, xTree, i + 1, typeLength);
}
xxTree = tree["**"];
if (xxTree) {
if (i < typeLength) {
if (xxTree._listeners) {
searchListenerTree(handlers, type, xxTree, typeLength, typeLength);
}
branches = ownKeys(xxTree);
n2 = branches.length;
while (n2-- > 0) {
branch = branches[n2];
if (branch !== "_listeners") {
if (branch === nextType) {
searchListenerTree(handlers, type, xxTree[branch], i + 2, typeLength);
} else if (branch === currentType) {
searchListenerTree(handlers, type, xxTree[branch], i + 1, typeLength);
} else {
isolatedBranch = {};
isolatedBranch[branch] = xxTree[branch];
searchListenerTree(handlers, type, { "**": isolatedBranch }, i + 1, typeLength);
}
}
}
} else if (xxTree._listeners) {
searchListenerTree(handlers, type, xxTree, typeLength, typeLength);
} else if (xxTree["*"] && xxTree["*"]._listeners) {
searchListenerTree(handlers, type, xxTree["*"], typeLength, typeLength);
}
}
return listeners;
}
function growListenerTree(type, listener, prepend) {
var len = 0, j2 = 0, i, delimiter = this.delimiter, dl2 = delimiter.length, ns2;
if (typeof type === "string") {
if ((i = type.indexOf(delimiter)) !== -1) {
ns2 = new Array(5);
do {
ns2[len++] = type.slice(j2, i);
j2 = i + dl2;
} while ((i = type.indexOf(delimiter, j2)) !== -1);
ns2[len++] = type.slice(j2);
} else {
ns2 = [type];
len = 1;
}
} else {
ns2 = type;
len = type.length;
}
if (len > 1) {
for (i = 0; i + 1 < len; i++) {
if (ns2[i] === "**" && ns2[i + 1] === "**") {
return;
}
}
}
var tree = this.listenerTree, name;
for (i = 0; i < len; i++) {
name = ns2[i];
tree = tree[name] || (tree[name] = {});
if (i === len - 1) {
if (!tree._listeners) {
tree._listeners = listener;
} else {
if (typeof tree._listeners === "function") {
tree._listeners = [tree._listeners];
}
if (prepend) {
tree._listeners.unshift(listener);
} else {
tree._listeners.push(listener);
}
if (!tree._listeners.warned && this._maxListeners > 0 && tree._listeners.length > this._maxListeners) {
tree._listeners.warned = true;
logPossibleMemoryLeak.call(this, tree._listeners.length, name);
}
}
return true;
}
}
return true;
}
function collectTreeEvents(tree, events, root, asArray) {
var branches = ownKeys(tree);
var i = branches.length;
var branch, branchName, path;
var hasListeners = tree["_listeners"];
var isArrayPath;
while (i-- > 0) {
branchName = branches[i];
branch = tree[branchName];
if (branchName === "_listeners") {
path = root;
} else {
path = root ? root.concat(branchName) : [branchName];
}
isArrayPath = asArray || typeof branchName === "symbol";
hasListeners && events.push(isArrayPath ? path : path.join(this.delimiter));
if (typeof branch === "object") {
collectTreeEvents.call(this, branch, events, path, isArrayPath);
}
}
return events;
}
function recursivelyGarbageCollect(root) {
var keys = ownKeys(root);
var i = keys.length;
var obj, key, flag;
while (i-- > 0) {
key = keys[i];
obj = root[key];
if (obj) {
flag = true;
if (key !== "_listeners" && !recursivelyGarbageCollect(obj)) {
delete root[key];
}
}
}
return flag;
}
function Listener(emitter, event, listener) {
this.emitter = emitter;
this.event = event;
this.listener = listener;
}
Listener.prototype.off = function() {
this.emitter.off(this.event, this.listener);
return this;
};
function setupListener(event, listener, options) {
if (options === true) {
promisify = true;
} else if (options === false) {
async = true;
} else {
if (!options || typeof options !== "object") {
throw TypeError("options should be an object or true");
}
var async = options.async;
var promisify = options.promisify;
var nextTick2 = options.nextTick;
var objectify = options.objectify;
}
if (async || nextTick2 || promisify) {
var _listener = listener;
var _origin = listener._origin || listener;
if (nextTick2 && !nextTickSupported) {
throw Error("process.nextTick is not supported");
}
if (promisify === undefined$1) {
promisify = listener.constructor.name === "AsyncFunction";
}
listener = function() {
var args = arguments;
var context = this;
var event2 = this.event;
return promisify ? nextTick2 ? Promise.resolve() : new Promise(function(resolve) {
_setImmediate(resolve);
}).then(function() {
context.event = event2;
return _listener.apply(context, args);
}) : (nextTick2 ? process$1.nextTick : _setImmediate)(function() {
context.event = event2;
_listener.apply(context, args);
});
};
listener._async = true;
listener._origin = _origin;
}
return [listener, objectify ? new Listener(this, event, listener) : this];
}
function EventEmitter(conf) {
this._events = {};
this._newListener = false;
this._removeListener = false;
this.verboseMemoryLeak = false;
configure.call(this, conf);
}
EventEmitter.EventEmitter2 = EventEmitter;
EventEmitter.prototype.listenTo = function(target, events, options) {
if (typeof target !== "object") {
throw TypeError("target musts be an object");
}
var emitter = this;
options = resolveOptions(options, {
on: undefined$1,
off: undefined$1,
reducers: undefined$1
}, {
on: functionReducer,
off: functionReducer,
reducers: objectFunctionReducer
});
function listen(events2) {
if (typeof events2 !== "object") {
throw TypeError("events must be an object");
}
var reducers = options.reducers;
var index = findTargetIndex.call(emitter, target);
var observer;
if (index === -1) {
observer = new TargetObserver(emitter, target, options);
} else {
observer = emitter._observers[index];
}
var keys = ownKeys(events2);
var len = keys.length;
var event;
var isSingleReducer = typeof reducers === "function";
for (var i = 0; i < len; i++) {
event = keys[i];
observer.subscribe(
event,
events2[event] || event,
isSingleReducer ? reducers : reducers && reducers[event]
);
}
}
isArray(events) ? listen(toObject(events)) : typeof events === "string" ? listen(toObject(events.split(/\s+/))) : listen(events);
return this;
};
EventEmitter.prototype.stopListeningTo = function(target, event) {
var observers = this._observers;
if (!observers) {
return false;
}
var i = observers.length;
var observer;
var matched = false;
if (target && typeof target !== "object") {
throw TypeError("target should be an object");
}
while (i-- > 0) {
observer = observers[i];
if (!target || observer._target === target) {
observer.unsubscribe(event);
matched = true;
}
}
return matched;
};
EventEmitter.prototype.delimiter = ".";
EventEmitter.prototype.setMaxListeners = function(n2) {
if (n2 !== undefined$1) {
this._maxListeners = n2;
if (!this._conf) this._conf = {};
this._conf.maxListeners = n2;
}
};
EventEmitter.prototype.getMaxListeners = function() {
return this._maxListeners;
};
EventEmitter.prototype.event = "";
EventEmitter.prototype.once = function(event, fn2, options) {
return this._once(event, fn2, false, options);
};
EventEmitter.prototype.prependOnceListener = function(event, fn2, options) {
return this._once(event, fn2, true, options);
};
EventEmitter.prototype._once = function(event, fn2, prepend, options) {
return this._many(event, 1, fn2, prepend, options);
};
EventEmitter.prototype.many = function(event, ttl, fn2, options) {
return this._many(event, ttl, fn2, false, options);
};
EventEmitter.prototype.prependMany = function(event, ttl, fn2, options) {
return this._many(event, ttl, fn2, true, options);
};
EventEmitter.prototype._many = function(event, ttl, fn2, prepend, options) {
var self2 = this;
if (typeof fn2 !== "function") {
throw new Error("many only accepts instances of Function");
}
function listener() {
if (--ttl === 0) {
self2.off(event, listener);
}
return fn2.apply(this, arguments);
}
listener._origin = fn2;
return this._on(event, listener, prepend, options);
};
EventEmitter.prototype.emit = function() {
if (!this._events && !this._all) {
return false;
}
this._events || init.call(this);
var type = arguments[0], ns2, wildcard = this.wildcard;
var args, l2, i, j2, containsSymbol;
if (type === "newListener" && !this._newListener) {
if (!this._events.newListener) {
return false;
}
}
if (wildcard) {
ns2 = type;
if (type !== "newListener" && type !== "removeListener") {
if (typeof type === "object") {
l2 = type.length;
if (symbolsSupported) {
for (i = 0; i < l2; i++) {
if (typeof type[i] === "symbol") {
containsSymbol = true;
break;
}
}
}
if (!containsSymbol) {
type = type.join(this.delimiter);
}
}
}
}
var al2 = arguments.length;
var handler;
if (this._all && this._all.length) {
handler = this._all.slice();
for (i = 0, l2 = handler.length; i < l2; i++) {
this.event = type;
switch (al2) {
case 1:
handler[i].call(this, type);
break;
case 2:
handler[i].call(this, type, arguments[1]);
break;
case 3:
handler[i].call(this, type, arguments[1], arguments[2]);
break;
default:
handler[i].apply(this, arguments);
}
}
}
if (wildcard) {
handler = [];
searchListenerTree.call(this, handler, ns2, this.listenerTree, 0, l2);
} else {
handler = this._events[type];
if (typeof handler === "function") {
this.event = type;
switch (al2) {
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
default:
args = new Array(al2 - 1);
for (j2 = 1; j2 < al2; j2++) args[j2 - 1] = arguments[j2];
handler.apply(this, args);
}
return true;
} else if (handler) {
handler = handler.slice();
}
}
if (handler && handler.length) {
if (al2 > 3) {
args = new Array(al2 - 1);
for (j2 = 1; j2 < al2; j2++) args[j2 - 1] = arguments[j2];
}
for (i = 0, l2 = handler.length; i < l2; i++) {
this.event = type;
switch (al2) {
case 1:
handler[i].call(this);
break;
case 2:
handler[i].call(this, arguments[1]);
break;
case 3:
handler[i].call(this, argum