photoeditorsdk
Version:
The most comprehensive photo editor SDK for HTML5
1,358 lines (1,328 loc) • 2.38 MB
JavaScript
(function() {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __markAsModule = function(target) {
return __defProp(target, "__esModule", { value: true });
};
var __commonJS = function(cb, mod) {
return function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
};
var __reExport = function(target, module, copyDefault, desc) {
if (module && typeof module === "object" || typeof module === "function")
for (var keys = __getOwnPropNames(module), i = 0, n = keys.length, key; i < n; i++) {
key = keys[i];
if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
__defProp(target, key, { get: function(k) {
return module[k];
}.bind(null, key), enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
}
return target;
};
var __toESM = function(module, isNodeMode) {
return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", !isNodeMode && module && module.__esModule ? { get: function() {
return module.default;
}, enumerable: true } : { value: module, enumerable: true })), module);
};
// ../../node_modules/asap/browser-raw.js
var require_browser_raw = __commonJS({
"../../node_modules/asap/browser-raw.js": function(exports, module) {
"use strict";
module.exports = rawAsap;
function rawAsap(task) {
if (!queue.length) {
requestFlush();
flushing = true;
}
queue[queue.length] = task;
}
var queue = [];
var flushing = false;
var requestFlush;
var index = 0;
var capacity = 1024;
function flush() {
while (index < queue.length) {
var currentIndex = index;
index = index + 1;
queue[currentIndex].call();
if (index > capacity) {
for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
queue[scan] = queue[scan + index];
}
queue.length -= index;
index = 0;
}
}
queue.length = 0;
index = 0;
flushing = false;
}
var scope = typeof global !== "undefined" ? global : self;
var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
if (typeof BrowserMutationObserver === "function") {
requestFlush = makeRequestCallFromMutationObserver(flush);
} else {
requestFlush = makeRequestCallFromTimer(flush);
}
rawAsap.requestFlush = requestFlush;
function makeRequestCallFromMutationObserver(callback) {
var toggle = 1;
var observer = new BrowserMutationObserver(callback);
var node = document.createTextNode("");
observer.observe(node, { characterData: true });
return function requestCall() {
toggle = -toggle;
node.data = toggle;
};
}
function makeRequestCallFromTimer(callback) {
return function requestCall() {
var timeoutHandle = setTimeout(handleTimer, 0);
var intervalHandle = setInterval(handleTimer, 50);
function handleTimer() {
clearTimeout(timeoutHandle);
clearInterval(intervalHandle);
callback();
}
};
}
rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
}
});
// ../../node_modules/promise/lib/core.js
var require_core = __commonJS({
"../../node_modules/promise/lib/core.js": function(exports, module) {
"use strict";
var asap = require_browser_raw();
function noop() {
}
var LAST_ERROR = null;
var IS_ERROR = {};
function getThen(obj) {
try {
return obj.then;
} catch (ex) {
LAST_ERROR = ex;
return IS_ERROR;
}
}
function tryCallOne(fn, a) {
try {
return fn(a);
} catch (ex) {
LAST_ERROR = ex;
return IS_ERROR;
}
}
function tryCallTwo(fn, a, b) {
try {
fn(a, b);
} catch (ex) {
LAST_ERROR = ex;
return IS_ERROR;
}
}
module.exports = Promise2;
function Promise2(fn) {
if (typeof this !== "object") {
throw new TypeError("Promises must be constructed via new");
}
if (typeof fn !== "function") {
throw new TypeError("Promise constructor's argument is not a function");
}
this._U = 0;
this._V = 0;
this._W = null;
this._X = null;
if (fn === noop)
return;
doResolve(fn, this);
}
Promise2._Y = null;
Promise2._Z = null;
Promise2._0 = noop;
Promise2.prototype.then = function(onFulfilled, onRejected) {
if (this.constructor !== Promise2) {
return safeThen(this, onFulfilled, onRejected);
}
var res = new Promise2(noop);
handle(this, new Handler(onFulfilled, onRejected, res));
return res;
};
function safeThen(self2, onFulfilled, onRejected) {
return new self2.constructor(function(resolve2, reject2) {
var res = new Promise2(noop);
res.then(resolve2, reject2);
handle(self2, new Handler(onFulfilled, onRejected, res));
});
}
function handle(self2, deferred) {
while (self2._V === 3) {
self2 = self2._W;
}
if (Promise2._Y) {
Promise2._Y(self2);
}
if (self2._V === 0) {
if (self2._U === 0) {
self2._U = 1;
self2._X = deferred;
return;
}
if (self2._U === 1) {
self2._U = 2;
self2._X = [self2._X, deferred];
return;
}
self2._X.push(deferred);
return;
}
handleResolved(self2, deferred);
}
function handleResolved(self2, deferred) {
asap(function() {
var cb = self2._V === 1 ? deferred.onFulfilled : deferred.onRejected;
if (cb === null) {
if (self2._V === 1) {
resolve(deferred.promise, self2._W);
} else {
reject(deferred.promise, self2._W);
}
return;
}
var ret = tryCallOne(cb, self2._W);
if (ret === IS_ERROR) {
reject(deferred.promise, LAST_ERROR);
} else {
resolve(deferred.promise, ret);
}
});
}
function resolve(self2, newValue) {
if (newValue === self2) {
return reject(self2, new TypeError("A promise cannot be resolved with itself."));
}
if (newValue && (typeof newValue === "object" || typeof newValue === "function")) {
var then = getThen(newValue);
if (then === IS_ERROR) {
return reject(self2, LAST_ERROR);
}
if (then === self2.then && newValue instanceof Promise2) {
self2._V = 3;
self2._W = newValue;
finale(self2);
return;
} else if (typeof then === "function") {
doResolve(then.bind(newValue), self2);
return;
}
}
self2._V = 1;
self2._W = newValue;
finale(self2);
}
function reject(self2, newValue) {
self2._V = 2;
self2._W = newValue;
if (Promise2._Z) {
Promise2._Z(self2, newValue);
}
finale(self2);
}
function finale(self2) {
if (self2._U === 1) {
handle(self2, self2._X);
self2._X = null;
}
if (self2._U === 2) {
for (var i = 0; i < self2._X.length; i++) {
handle(self2, self2._X[i]);
}
self2._X = null;
}
}
function Handler(onFulfilled, onRejected, promise) {
this.onFulfilled = typeof onFulfilled === "function" ? onFulfilled : null;
this.onRejected = typeof onRejected === "function" ? onRejected : null;
this.promise = promise;
}
function doResolve(fn, promise) {
var done = false;
var res = tryCallTwo(fn, function(value) {
if (done)
return;
done = true;
resolve(promise, value);
}, function(reason) {
if (done)
return;
done = true;
reject(promise, reason);
});
if (!done && res === IS_ERROR) {
done = true;
reject(promise, LAST_ERROR);
}
}
}
});
// ../../node_modules/promise/lib/rejection-tracking.js
var require_rejection_tracking = __commonJS({
"../../node_modules/promise/lib/rejection-tracking.js": function(exports) {
"use strict";
var Promise2 = require_core();
var DEFAULT_WHITELIST = [
ReferenceError,
TypeError,
RangeError
];
var enabled = false;
exports.disable = disable;
function disable() {
enabled = false;
Promise2._Y = null;
Promise2._Z = null;
}
exports.enable = enable;
function enable(options) {
options = options || {};
if (enabled)
disable();
enabled = true;
var id = 0;
var displayId = 0;
var rejections = {};
Promise2._Y = function(promise) {
if (promise._V === 2 && rejections[promise._1]) {
if (rejections[promise._1].logged) {
onHandled(promise._1);
} else {
clearTimeout(rejections[promise._1].timeout);
}
delete rejections[promise._1];
}
};
Promise2._Z = function(promise, err) {
if (promise._U === 0) {
promise._1 = id++;
rejections[promise._1] = {
displayId: null,
error: err,
timeout: setTimeout(onUnhandled.bind(null, promise._1), matchWhitelist(err, DEFAULT_WHITELIST) ? 100 : 2e3),
logged: false
};
}
};
function onUnhandled(id2) {
if (options.allRejections || matchWhitelist(rejections[id2].error, options.whitelist || DEFAULT_WHITELIST)) {
rejections[id2].displayId = displayId++;
if (options.onUnhandled) {
rejections[id2].logged = true;
options.onUnhandled(rejections[id2].displayId, rejections[id2].error);
} else {
rejections[id2].logged = true;
logError(rejections[id2].displayId, rejections[id2].error);
}
}
}
function onHandled(id2) {
if (rejections[id2].logged) {
if (options.onHandled) {
options.onHandled(rejections[id2].displayId, rejections[id2].error);
} else if (!rejections[id2].onUnhandled) {
console.warn("Promise Rejection Handled (id: " + rejections[id2].displayId + "):");
console.warn(' This means you can ignore any previous messages of the form "Possible Unhandled Promise Rejection" with id ' + rejections[id2].displayId + ".");
}
}
}
}
function logError(id, error) {
console.warn("Possible Unhandled Promise Rejection (id: " + id + "):");
var errStr = (error && (error.stack || error)) + "";
errStr.split("\n").forEach(function(line) {
console.warn(" " + line);
});
}
function matchWhitelist(error, list) {
return list.some(function(cls) {
return error instanceof cls;
});
}
}
});
// ../../node_modules/promise/lib/es6-extensions.js
var require_es6_extensions = __commonJS({
"../../node_modules/promise/lib/es6-extensions.js": function(exports, module) {
"use strict";
var Promise2 = require_core();
module.exports = Promise2;
var TRUE = valuePromise(true);
var FALSE = valuePromise(false);
var NULL = valuePromise(null);
var UNDEFINED = valuePromise(void 0);
var ZERO = valuePromise(0);
var EMPTYSTRING = valuePromise("");
function valuePromise(value) {
var p = new Promise2(Promise2._0);
p._V = 1;
p._W = value;
return p;
}
Promise2.resolve = function(value) {
if (value instanceof Promise2)
return value;
if (value === null)
return NULL;
if (value === void 0)
return UNDEFINED;
if (value === true)
return TRUE;
if (value === false)
return FALSE;
if (value === 0)
return ZERO;
if (value === "")
return EMPTYSTRING;
if (typeof value === "object" || typeof value === "function") {
try {
var then = value.then;
if (typeof then === "function") {
return new Promise2(then.bind(value));
}
} catch (ex) {
return new Promise2(function(resolve, reject) {
reject(ex);
});
}
}
return valuePromise(value);
};
var iterableToArray = function(iterable) {
if (typeof Array.from === "function") {
iterableToArray = Array.from;
return Array.from(iterable);
}
iterableToArray = function(x) {
return Array.prototype.slice.call(x);
};
return Array.prototype.slice.call(iterable);
};
Promise2.all = function(arr) {
var args = iterableToArray(arr);
return new Promise2(function(resolve, reject) {
if (args.length === 0)
return resolve([]);
var remaining = args.length;
function res(i2, val) {
if (val && (typeof val === "object" || typeof val === "function")) {
if (val instanceof Promise2 && val.then === Promise2.prototype.then) {
while (val._V === 3) {
val = val._W;
}
if (val._V === 1)
return res(i2, val._W);
if (val._V === 2)
reject(val._W);
val.then(function(val2) {
res(i2, val2);
}, reject);
return;
} else {
var then = val.then;
if (typeof then === "function") {
var p = new Promise2(then.bind(val));
p.then(function(val2) {
res(i2, val2);
}, reject);
return;
}
}
}
args[i2] = val;
if (--remaining === 0) {
resolve(args);
}
}
for (var i = 0; i < args.length; i++) {
res(i, args[i]);
}
});
};
Promise2.reject = function(value) {
return new Promise2(function(resolve, reject) {
reject(value);
});
};
Promise2.race = function(values) {
return new Promise2(function(resolve, reject) {
iterableToArray(values).forEach(function(value) {
Promise2.resolve(value).then(resolve, reject);
});
});
};
Promise2.prototype["catch"] = function(onRejected) {
return this.then(null, onRejected);
};
}
});
// ../../node_modules/whatwg-fetch/dist/fetch.umd.js
var require_fetch_umd = __commonJS({
"../../node_modules/whatwg-fetch/dist/fetch.umd.js": function(exports, module) {
(function(global2, factory) {
typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global2.WHATWGFetch = {});
})(exports, function(exports2) {
"use strict";
var global2 = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || typeof global2 !== "undefined" && global2;
var support = {
searchParams: "URLSearchParams" in global2,
iterable: "Symbol" in global2 && "iterator" in Symbol,
blob: "FileReader" in global2 && "Blob" in global2 && function() {
try {
new Blob();
return true;
} catch (e) {
return false;
}
}(),
formData: "FormData" in global2,
arrayBuffer: "ArrayBuffer" in global2
};
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");
}
return name.toLowerCase();
}
function normalizeValue(value) {
if (typeof value !== "string") {
value = String(value);
}
return value;
}
function iteratorFor(items) {
var iterator = {
next: function() {
var value = items.shift();
return { done: value === void 0, value: value };
}
};
if (support.iterable) {
iterator[Symbol.iterator] = function() {
return iterator;
};
}
return iterator;
}
function Headers(headers) {
this.map = {};
if (headers instanceof Headers) {
headers.forEach(function(value, name) {
this.append(name, value);
}, this);
} else if (Array.isArray(headers)) {
headers.forEach(function(header) {
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, value) {
name = normalizeName(name);
value = normalizeValue(value);
var oldValue = this.map[name];
this.map[name] = oldValue ? oldValue + ", " + value : value;
};
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, value) {
this.map[normalizeName(name)] = normalizeValue(value);
};
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(value, name) {
items.push(name);
});
return iteratorFor(items);
};
Headers.prototype.values = function() {
var items = [];
this.forEach(function(value) {
items.push(value);
});
return iteratorFor(items);
};
Headers.prototype.entries = function() {
var items = [];
this.forEach(function(value, name) {
items.push([name, value]);
});
return iteratorFor(items);
};
if (support.iterable) {
Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
}
function consumed(body) {
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);
reader.readAsText(blob);
return promise;
}
function readArrayBufferAsText(buf) {
var view = new Uint8Array(buf);
var chars = new Array(view.length);
for (var i = 0; i < view.length; i++) {
chars[i] = String.fromCharCode(view[i]);
}
return chars.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._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;
}
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 {
return this.blob().then(readBlobAsArrayBuffer);
}
};
}
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(decode);
};
}
this.json = function() {
return this.text().then(JSON.parse);
};
return this;
}
var methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
function normalizeMethod(method) {
var upcased = method.toUpperCase();
return methods.indexOf(upcased) > -1 ? upcased : method;
}
function Request(input, options) {
if (!(this instanceof Request)) {
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 Request) {
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;
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_=" + new Date().getTime());
} else {
var reQueryString = /\?/;
this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + new Date().getTime();
}
}
}
}
Request.prototype.clone = function() {
return new Request(this, { body: this._bodyInit });
};
function decode(body) {
var form = new FormData();
body.trim().split("&").forEach(function(bytes) {
if (bytes) {
var split = bytes.split("=");
var name = split.shift().replace(/\+/g, " ");
var value = split.join("=").replace(/\+/g, " ");
form.append(decodeURIComponent(name), decodeURIComponent(value));
}
});
return form;
}
function parseHeaders(rawHeaders) {
var headers = new Headers();
var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
var parts = line.split(":");
var key = parts.shift().trim();
if (key) {
var value = parts.join(":").trim();
headers.append(key, value);
}
});
return headers;
}
Body.call(Request.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;
this.ok = this.status >= 200 && this.status < 300;
this.statusText = "statusText" in options ? 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: 0, statusText: "" });
response.type = "error";
return response;
};
var redirectStatuses = [301, 302, 303, 307, 308];
Response.redirect = function(url, status) {
if (redirectStatuses.indexOf(status) === -1) {
throw new RangeError("Invalid status code");
}
return new Response(null, { status: status, headers: { location: url } });
};
exports2.DOMException = global2.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 fetch(input, init) {
return new Promise(function(resolve, reject) {
var request = new Request(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 = {
status: xhr.status,
statusText: xhr.statusText,
headers: parseHeaders(xhr.getAllResponseHeaders() || "")
};
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 failed"));
}, 0);
};
xhr.onabort = function() {
setTimeout(function() {
reject(new exports2.DOMException("Aborted", "AbortError"));
}, 0);
};
function fixUrl(url) {
try {
return url === "" && global2.location.href ? global2.location.href : url;
} catch (e) {
return url;
}
}
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 && request.headers.get("Content-Type") && request.headers.get("Content-Type").indexOf("application/octet-stream") !== -1) {
xhr.responseType = "arraybuffer";
}
}
if (init && typeof init.headers === "object" && !(init.headers instanceof Headers)) {
Object.getOwnPropertyNames(init.headers).forEach(function(name) {
xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
});
} else {
request.headers.forEach(function(value, name) {
xhr.setRequestHeader(name, value);
});
}
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);
});
}
fetch.polyfill = true;
if (!global2.fetch) {
global2.fetch = fetch;
global2.Headers = Headers;
global2.Request = Request;
global2.Response = Response;
}
exports2.Headers = Headers;
exports2.Request = Request;
exports2.Response = Response;
exports2.fetch = fetch;
Object.defineProperty(exports2, "__esModule", { value: true });
});
}
});
// ../../node_modules/object-assign/index.js
var require_object_assign = __commonJS({
"../../node_modules/object-assign/index.js": function(exports, module) {
"use strict";
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === void 0) {
throw new TypeError("Object.assign cannot be called with null or undefined");
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
var test1 = new String("abc");
test1[5] = "de";
if (Object.getOwnPropertyNames(test1)[0] === "5") {
return false;
}
var test2 = {};
for (var i = 0; i < 10; i++) {
test2["_" + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
return test2[n];
});
if (order2.join("") !== "0123456789") {
return false;
}
var test3 = {};
"abcdefghijklmnopqrst".split("").forEach(function(letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
return false;
}
return true;
} catch (err) {
return false;
}
}
module.exports = shouldUseNative() ? Object.assign : function(target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
}
});
// ../../node_modules/core-js/internals/global.js
var require_global = __commonJS({
"../../node_modules/core-js/internals/global.js": function(exports, module) {
var check = function(it) {
return it && it.Math == Math && it;
};
module.exports = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof global == "object" && global) || Function("return this")();
}
});
// ../../node_modules/core-js/internals/fails.js
var require_fails = __commonJS({
"../../node_modules/core-js/internals/fails.js": function(exports, module) {
module.exports = function(exec) {
try {
return !!exec();
} catch (error) {
return true;
}
};
}
});
// ../../node_modules/core-js/internals/descriptors.js
var require_descriptors = __commonJS({
"../../node_modules/core-js/internals/descriptors.js": function(exports, module) {
var fails = require_fails();
module.exports = !fails(function() {
return Object.defineProperty({}, 1, { get: function() {
return 7;
} })[1] != 7;
});
}
});
// ../../node_modules/core-js/internals/object-property-is-enumerable.js
var require_object_property_is_enumerable = __commonJS({
"../../node_modules/core-js/internals/object-property-is-enumerable.js": function(exports) {
"use strict";
var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
var descriptor = getOwnPropertyDescriptor(this, V);
return !!descriptor && descriptor.enumerable;
} : nativePropertyIsEnumerable;
}
});
// ../../node_modules/core-js/internals/create-property-descriptor.js
var require_create_property_descriptor = __commonJS({
"../../node_modules/core-js/internals/create-property-descriptor.js": function(exports, module) {
module.exports = function(bitmap, value) {
return {
enumerable: !(bitmap & 1),
configurable: !(bitmap & 2),
writable: !(bitmap & 4),
value: value
};
};
}
});
// ../../node_modules/core-js/internals/classof-raw.js
var require_classof_raw = __commonJS({
"../../node_modules/core-js/internals/classof-raw.js": function(exports, module) {
var toString = {}.toString;
module.exports = function(it) {
return toString.call(it).slice(8, -1);
};
}
});
// ../../node_modules/core-js/internals/indexed-object.js
var require_indexed_object = __commonJS({
"../../node_modules/core-js/internals/indexed-object.js": function(exports, module) {
var fails = require_fails();
var classof = require_classof_raw();
var split = "".split;
module.exports = fails(function() {
return !Object("z").propertyIsEnumerable(0);
}) ? function(it) {
return classof(it) == "String" ? split.call(it, "") : Object(it);
} : Object;
}
});
// ../../node_modules/core-js/internals/require-object-coercible.js
var require_require_object_coercible = __commonJS({
"../../node_modules/core-js/internals/require-object-coercible.js": function(exports, module) {
module.exports = function(it) {
if (it == void 0)
throw TypeError("Can't call method on " + it);
return it;
};
}
});
// ../../node_modules/core-js/internals/to-indexed-object.js
var require_to_indexed_object = __commonJS({
"../../node_modules/core-js/internals/to-indexed-object.js": function(exports, module) {
var IndexedObject = require_indexed_object();
var requireObjectCoercible = require_require_object_coercible();
module.exports = function(it) {
return IndexedObject(requireObjectCoercible(it));
};
}
});
// ../../node_modules/core-js/internals/is-object.js
var require_is_object = __commonJS({
"../../node_modules/core-js/internals/is-object.js": function(exports, module) {
module.exports = function(it) {
return typeof it === "object" ? it !== null : typeof it === "function";
};
}
});
// ../../node_modules/core-js/internals/to-primitive.js
var require_to_primitive = __commonJS({
"../../node_modules/core-js/internals/to-primitive.js": function(exports, module) {
var isObject = require_is_object();
module.exports = function(input, PREFERRED_STRING) {
if (!isObject(input))
return input;
var fn, val;
if (PREFERRED_STRING && typeof (fn = input.toString) == "function" && !isObject(val = fn.call(input)))
return val;
if (typeof (fn = input.valueOf) == "function" && !isObject(val = fn.call(input)))
return val;
if (!PREFERRED_STRING && typeof (fn = input.toString) == "function" && !isObject(val = fn.call(input)))
return val;
throw TypeError("Can't convert object to primitive value");
};
}
});
// ../../node_modules/core-js/internals/has.js
var require_has = __commonJS({
"../../node_modules/core-js/internals/has.js": function(exports, module) {
var hasOwnProperty = {}.hasOwnProperty;
module.exports = function(it, key) {
return hasOwnProperty.call(it, key);
};
}
});
// ../../node_modules/core-js/internals/document-create-element.js
var require_document_create_element = __commonJS({
"../../node_modules/core-js/internals/document-create-element.js": function(exports, module) {
var global2 = require_global();
var isObject = require_is_object();
var document2 = global2.document;
var EXISTS = isObject(document2) && isObject(document2.createElement);
module.exports = function(it) {
return EXISTS ? document2.createElement(it) : {};
};
}
});
// ../../node_modules/core-js/internals/ie8-dom-define.js
var require_ie8_dom_define = __commonJS({
"../../node_modules/core-js/internals/ie8-dom-define.js": function(exports, module) {
var DESCRIPTORS = require_descriptors();
var fails = require_fails();
var createElement = require_document_create_element();
module.exports = !DESCRIPTORS && !fails(function() {
return Object.defineProperty(createElement("div"), "a", {
get: function() {
return 7;
}
}).a != 7;
});
}
});
// ../../node_modules/core-js/internals/object-get-own-property-descriptor.js
var require_object_get_own_property_descriptor = __commonJS({
"../../node_modules/core-js/internals/object-get-own-property-descriptor.js": function(exports) {
var DESCRIPTORS = require_descriptors();
var propertyIsEnumerableModule = require_object_property_is_enumerable();
var createPropertyDescriptor = require_create_property_descriptor();
var toIndexedObject = require_to_indexed_object();
var toPrimitive = require_to_primitive();
var has = require_has();
var IE8_DOM_DEFINE = require_ie8_dom_define();
var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
O = toIndexedObject(O);
P = toPrimitive(P, true);
if (IE8_DOM_DEFINE)
try {
return nativeGetOwnPropertyDescriptor(O, P);
} catch (error) {
}
if (has(O, P))
return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
};
}
});
// ../../node_modules/core-js/internals/an-object.js
var require_an_object = __commonJS({
"../../node_modules/core-js/internals/an-object.js": function(exports, module) {
var isObject = require_is_object();
module.exports = function(it) {
if (!isObject(it)) {
throw TypeError(String(it) + " is not an object");
}
return it;
};
}
});
// ../../node_modules/core-js/internals/object-define-property.js
var require_object_define_property = __commonJS({
"../../node_modules/core-js/internals/object-define-property.js": function(exports) {
var DESCRIPTORS = require_descriptors();
var IE8_DOM_DEFINE = require_ie8_dom_define();
var anObject = require_an_object();
var toPrimitive = require_to_primitive();
var nativeDefineProperty = Object.defineProperty;
exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
anObject(O);
P = toPrimitive(P, true);
anObject(Attributes);
if (IE8_DOM_DEFINE)
try {
return nativeDefineProperty(O, P, Attributes);
} catch (error) {
}
if ("get" in Attributes || "set" in Attributes)
throw TypeError("Accessors not supported");
if ("value" in Attributes)
O[P] = Attributes.value;
return O;
};
}
});
// ../../node_modules/core-js/internals/create-non-enumerable-property.js
var require_create_non_enumerable_property = __commonJS({
"../../node_modules/core-js/internals/create-non-enumerable-property.js": function(exports, module) {
var DESCRIPTORS = require_descriptors();
var definePropertyModule = require_object_define_property();
var createPropertyDescriptor = require_create_property_descriptor();
module.exports = DESCRIPTORS ? function(object, key, value) {
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
} : function(object, key, value) {
object[key] = value;
return object;
};
}
});
// ../../node_modules/core-js/internals/set-global.js
var require_set_global = __commonJS({
"../../node_modules/core-js/internals/set-global.js": function(exports, module) {
var global2 = require_global();
var createNonEnumerableProperty = require_create_non_enumerable_property();
module.exports = function(key, value) {
try {
createNonEnumerableProperty(global2, key, value);
} catch (error) {
global2[key] = value;
}
return value;
};
}
});
// ../../node_modules/core-js/internals/shared-store.js
var require_shared_store = __commonJS({
"../../node_modules/core-js/internals/shared-store.js": function(exports, module) {
var global2 = require_global();
var setGlobal = require_set_global();
var SHARED = "__core-js_shared__";
var store = global2[SHARED] || setGlobal(SHARED, {});
module.exports = store;
}
});
// ../../node_modules/core-js/internals/inspect-source.js
var require_inspect_source = __commonJS({
"../../node_modules/core-js/internals/inspect-source.js": function(exports, module) {
var store = require_shared_store();
var functionToString = Function.toString;
if (typeof store.inspectSource != "function") {
store.inspectSource = function(it) {
return functionToString.call(it);
};
}
module.exports = store.inspectSource;
}
});
// ../../node_modules/core-js/internals/native-weak-map.js
var require_native_weak_map = __commonJS({
"../../node_modules/core-js/internals/native-weak-map.js": function(exports, module) {
var global2 = require_global();
var inspectSource = require_inspect_source();
var WeakMap2 = global2.WeakMap;
module.exports = typeof WeakMap2 === "function" && /native code/.test(inspectSource(WeakMap2));
}
});
// ../../node_modules/core-js/internals/is-pure.js
var require_is_pure = __commonJS({
"../../node_modules/core-js/internals/is-pure.js": function(exports, module) {
module.exports = false;
}
});
// ../../node_modules/core-js/internals/shared.j