testplane
Version:
Tests framework based on mocha and wdio
1,469 lines (1,459 loc) • 634 kB
JavaScript
"use strict";
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 __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/bluebird/js/release/es5.js
var require_es5 = __commonJS({
"node_modules/bluebird/js/release/es5.js"(exports2, module2) {
var isES5 = function() {
"use strict";
return this === void 0;
}();
if (isES5) {
module2.exports = {
freeze: Object.freeze,
defineProperty: Object.defineProperty,
getDescriptor: Object.getOwnPropertyDescriptor,
keys: Object.keys,
names: Object.getOwnPropertyNames,
getPrototypeOf: Object.getPrototypeOf,
isArray: Array.isArray,
isES5,
propertyIsWritable: function(obj2, prop) {
var descriptor = Object.getOwnPropertyDescriptor(obj2, prop);
return !!(!descriptor || descriptor.writable || descriptor.set);
}
};
} else {
has = {}.hasOwnProperty;
str = {}.toString;
proto = {}.constructor.prototype;
ObjectKeys = function(o) {
var ret2 = [];
for (var key in o) {
if (has.call(o, key)) {
ret2.push(key);
}
}
return ret2;
};
ObjectGetDescriptor = function(o, key) {
return { value: o[key] };
};
ObjectDefineProperty = function(o, key, desc) {
o[key] = desc.value;
return o;
};
ObjectFreeze = function(obj2) {
return obj2;
};
ObjectGetPrototypeOf = function(obj2) {
try {
return Object(obj2).constructor.prototype;
} catch (e) {
return proto;
}
};
ArrayIsArray = function(obj2) {
try {
return str.call(obj2) === "[object Array]";
} catch (e) {
return false;
}
};
module2.exports = {
isArray: ArrayIsArray,
keys: ObjectKeys,
names: ObjectKeys,
defineProperty: ObjectDefineProperty,
getDescriptor: ObjectGetDescriptor,
freeze: ObjectFreeze,
getPrototypeOf: ObjectGetPrototypeOf,
isES5,
propertyIsWritable: function() {
return true;
}
};
}
var has;
var str;
var proto;
var ObjectKeys;
var ObjectGetDescriptor;
var ObjectDefineProperty;
var ObjectFreeze;
var ObjectGetPrototypeOf;
var ArrayIsArray;
}
});
// node_modules/bluebird/js/release/util.js
var require_util = __commonJS({
"node_modules/bluebird/js/release/util.js"(exports, module) {
"use strict";
var es5 = require_es5();
var canEvaluate = typeof navigator == "undefined";
var errorObj = { e: {} };
var tryCatchTarget;
var globalObject = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : exports !== void 0 ? exports : null;
function tryCatcher() {
try {
var target = tryCatchTarget;
tryCatchTarget = null;
return target.apply(this, arguments);
} catch (e) {
errorObj.e = e;
return errorObj;
}
}
function tryCatch(fn) {
tryCatchTarget = fn;
return tryCatcher;
}
var inherits = function(Child, Parent) {
var hasProp = {}.hasOwnProperty;
function T() {
this.constructor = Child;
this.constructor$ = Parent;
for (var propertyName in Parent.prototype) {
if (hasProp.call(Parent.prototype, propertyName) && propertyName.charAt(propertyName.length - 1) !== "$") {
this[propertyName + "$"] = Parent.prototype[propertyName];
}
}
}
T.prototype = Parent.prototype;
Child.prototype = new T();
return Child.prototype;
};
function isPrimitive(val) {
return val == null || val === true || val === false || typeof val === "string" || typeof val === "number";
}
function isObject(value) {
return typeof value === "function" || typeof value === "object" && value !== null;
}
function maybeWrapAsError(maybeError) {
if (!isPrimitive(maybeError)) return maybeError;
return new Error(safeToString(maybeError));
}
function withAppended(target, appendee) {
var len = target.length;
var ret2 = new Array(len + 1);
var i;
for (i = 0; i < len; ++i) {
ret2[i] = target[i];
}
ret2[i] = appendee;
return ret2;
}
function getDataPropertyOrDefault(obj2, key, defaultValue) {
if (es5.isES5) {
var desc = Object.getOwnPropertyDescriptor(obj2, key);
if (desc != null) {
return desc.get == null && desc.set == null ? desc.value : defaultValue;
}
} else {
return {}.hasOwnProperty.call(obj2, key) ? obj2[key] : void 0;
}
}
function notEnumerableProp(obj2, name, value) {
if (isPrimitive(obj2)) return obj2;
var descriptor = {
value,
configurable: true,
enumerable: false,
writable: true
};
es5.defineProperty(obj2, name, descriptor);
return obj2;
}
function thrower(r) {
throw r;
}
var inheritedDataKeys = function() {
var excludedPrototypes = [
Array.prototype,
Object.prototype,
Function.prototype
];
var isExcludedProto = function(val) {
for (var i = 0; i < excludedPrototypes.length; ++i) {
if (excludedPrototypes[i] === val) {
return true;
}
}
return false;
};
if (es5.isES5) {
var getKeys = Object.getOwnPropertyNames;
return function(obj2) {
var ret2 = [];
var visitedKeys = /* @__PURE__ */ Object.create(null);
while (obj2 != null && !isExcludedProto(obj2)) {
var keys;
try {
keys = getKeys(obj2);
} catch (e) {
return ret2;
}
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (visitedKeys[key]) continue;
visitedKeys[key] = true;
var desc = Object.getOwnPropertyDescriptor(obj2, key);
if (desc != null && desc.get == null && desc.set == null) {
ret2.push(key);
}
}
obj2 = es5.getPrototypeOf(obj2);
}
return ret2;
};
} else {
var hasProp = {}.hasOwnProperty;
return function(obj2) {
if (isExcludedProto(obj2)) return [];
var ret2 = [];
enumeration: for (var key in obj2) {
if (hasProp.call(obj2, key)) {
ret2.push(key);
} else {
for (var i = 0; i < excludedPrototypes.length; ++i) {
if (hasProp.call(excludedPrototypes[i], key)) {
continue enumeration;
}
}
ret2.push(key);
}
}
return ret2;
};
}
}();
var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
function isClass(fn) {
try {
if (typeof fn === "function") {
var keys = es5.names(fn.prototype);
var hasMethods = es5.isES5 && keys.length > 1;
var hasMethodsOtherThanConstructor = keys.length > 0 && !(keys.length === 1 && keys[0] === "constructor");
var hasThisAssignmentAndStaticMethods = thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
if (hasMethods || hasMethodsOtherThanConstructor || hasThisAssignmentAndStaticMethods) {
return true;
}
}
return false;
} catch (e) {
return false;
}
}
function toFastProperties(obj) {
function FakeConstructor() {
}
FakeConstructor.prototype = obj;
var l = 8;
while (l--) new FakeConstructor();
return obj;
eval(obj);
}
var rident = /^[a-z$_][a-z$_0-9]*$/i;
function isIdentifier(str) {
return rident.test(str);
}
function filledRange(count, prefix, suffix) {
var ret2 = new Array(count);
for (var i = 0; i < count; ++i) {
ret2[i] = prefix + i + suffix;
}
return ret2;
}
function safeToString(obj2) {
try {
return obj2 + "";
} catch (e) {
return "[no string representation]";
}
}
function isError(obj2) {
return obj2 instanceof Error || obj2 !== null && typeof obj2 === "object" && typeof obj2.message === "string" && typeof obj2.name === "string";
}
function markAsOriginatingFromRejection(e) {
try {
notEnumerableProp(e, "isOperational", true);
} catch (ignore) {
}
}
function originatesFromRejection(e) {
if (e == null) return false;
return e instanceof Error["__BluebirdErrorTypes__"].OperationalError || e["isOperational"] === true;
}
function canAttachTrace(obj2) {
return isError(obj2) && es5.propertyIsWritable(obj2, "stack");
}
var ensureErrorObject = function() {
if (!("stack" in new Error())) {
return function(value) {
if (canAttachTrace(value)) return value;
try {
throw new Error(safeToString(value));
} catch (err) {
return err;
}
};
} else {
return function(value) {
if (canAttachTrace(value)) return value;
return new Error(safeToString(value));
};
}
}();
function classString(obj2) {
return {}.toString.call(obj2);
}
function copyDescriptors(from, to, filter) {
var keys = es5.names(from);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (filter(key)) {
try {
es5.defineProperty(to, key, es5.getDescriptor(from, key));
} catch (ignore) {
}
}
}
}
var asArray = function(v) {
if (es5.isArray(v)) {
return v;
}
return null;
};
if (typeof Symbol !== "undefined" && Symbol.iterator) {
ArrayFrom = typeof Array.from === "function" ? function(v) {
return Array.from(v);
} : function(v) {
var ret2 = [];
var it = v[Symbol.iterator]();
var itResult;
while (!(itResult = it.next()).done) {
ret2.push(itResult.value);
}
return ret2;
};
asArray = function(v) {
if (es5.isArray(v)) {
return v;
} else if (v != null && typeof v[Symbol.iterator] === "function") {
return ArrayFrom(v);
}
return null;
};
}
var ArrayFrom;
var isNode = typeof process !== "undefined" && classString(process).toLowerCase() === "[object process]";
var hasEnvVariables = typeof process !== "undefined" && typeof process.env !== "undefined";
function env(key) {
return hasEnvVariables ? process.env[key] : void 0;
}
function getNativePromise() {
if (typeof Promise === "function") {
try {
var promise = new Promise(function() {
});
if ({}.toString.call(promise) === "[object Promise]") {
return Promise;
}
} catch (e) {
}
}
}
function domainBind(self2, cb) {
return self2.bind(cb);
}
var ret = {
isClass,
isIdentifier,
inheritedDataKeys,
getDataPropertyOrDefault,
thrower,
isArray: es5.isArray,
asArray,
notEnumerableProp,
isPrimitive,
isObject,
isError,
canEvaluate,
errorObj,
tryCatch,
inherits,
withAppended,
maybeWrapAsError,
toFastProperties,
filledRange,
toString: safeToString,
canAttachTrace,
ensureErrorObject,
originatesFromRejection,
markAsOriginatingFromRejection,
classString,
copyDescriptors,
hasDevTools: typeof chrome !== "undefined" && chrome && typeof chrome.loadTimes === "function",
isNode,
hasEnvVariables,
env,
global: globalObject,
getNativePromise,
domainBind
};
ret.isRecentNode = ret.isNode && function() {
var version = process.versions.node.split(".").map(Number);
return version[0] === 0 && version[1] > 10 || version[0] > 0;
}();
if (ret.isNode) ret.toFastProperties(process);
try {
throw new Error();
} catch (e) {
ret.lastLineError = e;
}
module.exports = ret;
}
});
// node_modules/bluebird/js/release/schedule.js
var require_schedule = __commonJS({
"node_modules/bluebird/js/release/schedule.js"(exports2, module2) {
"use strict";
var util = require_util();
var schedule;
var noAsyncScheduler = function() {
throw new Error("No async scheduler available\n\n See http://goo.gl/MqrFmX\n");
};
var NativePromise = util.getNativePromise();
if (util.isNode && typeof MutationObserver === "undefined") {
GlobalSetImmediate = global.setImmediate;
ProcessNextTick = process.nextTick;
schedule = util.isRecentNode ? function(fn) {
GlobalSetImmediate.call(global, fn);
} : function(fn) {
ProcessNextTick.call(process, fn);
};
} else if (typeof NativePromise === "function" && typeof NativePromise.resolve === "function") {
nativePromise = NativePromise.resolve();
schedule = function(fn) {
nativePromise.then(fn);
};
} else if (typeof MutationObserver !== "undefined" && !(typeof window !== "undefined" && window.navigator && (window.navigator.standalone || window.cordova))) {
schedule = function() {
var div = document.createElement("div");
var opts = { attributes: true };
var toggleScheduled = false;
var div2 = document.createElement("div");
var o2 = new MutationObserver(function() {
div.classList.toggle("foo");
toggleScheduled = false;
});
o2.observe(div2, opts);
var scheduleToggle = function() {
if (toggleScheduled) return;
toggleScheduled = true;
div2.classList.toggle("foo");
};
return function schedule2(fn) {
var o = new MutationObserver(function() {
o.disconnect();
fn();
});
o.observe(div, opts);
scheduleToggle();
};
}();
} else if (typeof setImmediate !== "undefined") {
schedule = function(fn) {
setImmediate(fn);
};
} else if (typeof setTimeout !== "undefined") {
schedule = function(fn) {
setTimeout(fn, 0);
};
} else {
schedule = noAsyncScheduler;
}
var GlobalSetImmediate;
var ProcessNextTick;
var nativePromise;
module2.exports = schedule;
}
});
// node_modules/bluebird/js/release/queue.js
var require_queue = __commonJS({
"node_modules/bluebird/js/release/queue.js"(exports2, module2) {
"use strict";
function arrayMove(src, srcIndex, dst, dstIndex, len) {
for (var j = 0; j < len; ++j) {
dst[j + dstIndex] = src[j + srcIndex];
src[j + srcIndex] = void 0;
}
}
function Queue(capacity) {
this._capacity = capacity;
this._length = 0;
this._front = 0;
}
Queue.prototype._willBeOverCapacity = function(size) {
return this._capacity < size;
};
Queue.prototype._pushOne = function(arg) {
var length = this.length();
this._checkCapacity(length + 1);
var i = this._front + length & this._capacity - 1;
this[i] = arg;
this._length = length + 1;
};
Queue.prototype.push = function(fn, receiver, arg) {
var length = this.length() + 3;
if (this._willBeOverCapacity(length)) {
this._pushOne(fn);
this._pushOne(receiver);
this._pushOne(arg);
return;
}
var j = this._front + length - 3;
this._checkCapacity(length);
var wrapMask = this._capacity - 1;
this[j + 0 & wrapMask] = fn;
this[j + 1 & wrapMask] = receiver;
this[j + 2 & wrapMask] = arg;
this._length = length;
};
Queue.prototype.shift = function() {
var front = this._front, ret2 = this[front];
this[front] = void 0;
this._front = front + 1 & this._capacity - 1;
this._length--;
return ret2;
};
Queue.prototype.length = function() {
return this._length;
};
Queue.prototype._checkCapacity = function(size) {
if (this._capacity < size) {
this._resizeTo(this._capacity << 1);
}
};
Queue.prototype._resizeTo = function(capacity) {
var oldCapacity = this._capacity;
this._capacity = capacity;
var front = this._front;
var length = this._length;
var moveItemsCount = front + length & oldCapacity - 1;
arrayMove(this, 0, this, oldCapacity, moveItemsCount);
};
module2.exports = Queue;
}
});
// node_modules/bluebird/js/release/async.js
var require_async = __commonJS({
"node_modules/bluebird/js/release/async.js"(exports2, module2) {
"use strict";
var firstLineError;
try {
throw new Error();
} catch (e) {
firstLineError = e;
}
var schedule = require_schedule();
var Queue = require_queue();
var util = require_util();
function Async() {
this._customScheduler = false;
this._isTickUsed = false;
this._lateQueue = new Queue(16);
this._normalQueue = new Queue(16);
this._haveDrainedQueues = false;
this._trampolineEnabled = true;
var self2 = this;
this.drainQueues = function() {
self2._drainQueues();
};
this._schedule = schedule;
}
Async.prototype.setScheduler = function(fn) {
var prev = this._schedule;
this._schedule = fn;
this._customScheduler = true;
return prev;
};
Async.prototype.hasCustomScheduler = function() {
return this._customScheduler;
};
Async.prototype.enableTrampoline = function() {
this._trampolineEnabled = true;
};
Async.prototype.disableTrampolineIfNecessary = function() {
if (util.hasDevTools) {
this._trampolineEnabled = false;
}
};
Async.prototype.haveItemsQueued = function() {
return this._isTickUsed || this._haveDrainedQueues;
};
Async.prototype.fatalError = function(e, isNode2) {
if (isNode2) {
process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) + "\n");
process.exit(2);
} else {
this.throwLater(e);
}
};
Async.prototype.throwLater = function(fn, arg) {
if (arguments.length === 1) {
arg = fn;
fn = function() {
throw arg;
};
}
if (typeof setTimeout !== "undefined") {
setTimeout(function() {
fn(arg);
}, 0);
} else try {
this._schedule(function() {
fn(arg);
});
} catch (e) {
throw new Error("No async scheduler available\n\n See http://goo.gl/MqrFmX\n");
}
};
function AsyncInvokeLater(fn, receiver, arg) {
this._lateQueue.push(fn, receiver, arg);
this._queueTick();
}
function AsyncInvoke(fn, receiver, arg) {
this._normalQueue.push(fn, receiver, arg);
this._queueTick();
}
function AsyncSettlePromises(promise) {
this._normalQueue._pushOne(promise);
this._queueTick();
}
if (!util.hasDevTools) {
Async.prototype.invokeLater = AsyncInvokeLater;
Async.prototype.invoke = AsyncInvoke;
Async.prototype.settlePromises = AsyncSettlePromises;
} else {
Async.prototype.invokeLater = function(fn, receiver, arg) {
if (this._trampolineEnabled) {
AsyncInvokeLater.call(this, fn, receiver, arg);
} else {
this._schedule(function() {
setTimeout(function() {
fn.call(receiver, arg);
}, 100);
});
}
};
Async.prototype.invoke = function(fn, receiver, arg) {
if (this._trampolineEnabled) {
AsyncInvoke.call(this, fn, receiver, arg);
} else {
this._schedule(function() {
fn.call(receiver, arg);
});
}
};
Async.prototype.settlePromises = function(promise) {
if (this._trampolineEnabled) {
AsyncSettlePromises.call(this, promise);
} else {
this._schedule(function() {
promise._settlePromises();
});
}
};
}
Async.prototype._drainQueue = function(queue) {
while (queue.length() > 0) {
var fn = queue.shift();
if (typeof fn !== "function") {
fn._settlePromises();
continue;
}
var receiver = queue.shift();
var arg = queue.shift();
fn.call(receiver, arg);
}
};
Async.prototype._drainQueues = function() {
this._drainQueue(this._normalQueue);
this._reset();
this._haveDrainedQueues = true;
this._drainQueue(this._lateQueue);
};
Async.prototype._queueTick = function() {
if (!this._isTickUsed) {
this._isTickUsed = true;
this._schedule(this.drainQueues);
}
};
Async.prototype._reset = function() {
this._isTickUsed = false;
};
module2.exports = Async;
module2.exports.firstLineError = firstLineError;
}
});
// node_modules/bluebird/js/release/errors.js
var require_errors = __commonJS({
"node_modules/bluebird/js/release/errors.js"(exports2, module2) {
"use strict";
var es52 = require_es5();
var Objectfreeze = es52.freeze;
var util = require_util();
var inherits2 = util.inherits;
var notEnumerableProp2 = util.notEnumerableProp;
function subError(nameProperty, defaultMessage) {
function SubError(message) {
if (!(this instanceof SubError)) return new SubError(message);
notEnumerableProp2(
this,
"message",
typeof message === "string" ? message : defaultMessage
);
notEnumerableProp2(this, "name", nameProperty);
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
} else {
Error.call(this);
}
}
inherits2(SubError, Error);
return SubError;
}
var _TypeError;
var _RangeError;
var Warning = subError("Warning", "warning");
var CancellationError = subError("CancellationError", "cancellation error");
var TimeoutError = subError("TimeoutError", "timeout error");
var AggregateError = subError("AggregateError", "aggregate error");
try {
_TypeError = TypeError;
_RangeError = RangeError;
} catch (e) {
_TypeError = subError("TypeError", "type error");
_RangeError = subError("RangeError", "range error");
}
var methods = "join pop push shift unshift slice filter forEach some every map indexOf lastIndexOf reduce reduceRight sort reverse".split(" ");
for (i = 0; i < methods.length; ++i) {
if (typeof Array.prototype[methods[i]] === "function") {
AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
}
}
var i;
es52.defineProperty(AggregateError.prototype, "length", {
value: 0,
configurable: false,
writable: true,
enumerable: true
});
AggregateError.prototype["isOperational"] = true;
var level = 0;
AggregateError.prototype.toString = function() {
var indent = Array(level * 4 + 1).join(" ");
var ret2 = "\n" + indent + "AggregateError of:\n";
level++;
indent = Array(level * 4 + 1).join(" ");
for (var i2 = 0; i2 < this.length; ++i2) {
var str = this[i2] === this ? "[Circular AggregateError]" : this[i2] + "";
var lines = str.split("\n");
for (var j = 0; j < lines.length; ++j) {
lines[j] = indent + lines[j];
}
str = lines.join("\n");
ret2 += str + "\n";
}
level--;
return ret2;
};
function OperationalError(message) {
if (!(this instanceof OperationalError))
return new OperationalError(message);
notEnumerableProp2(this, "name", "OperationalError");
notEnumerableProp2(this, "message", message);
this.cause = message;
this["isOperational"] = true;
if (message instanceof Error) {
notEnumerableProp2(this, "message", message.message);
notEnumerableProp2(this, "stack", message.stack);
} else if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
}
}
inherits2(OperationalError, Error);
var errorTypes = Error["__BluebirdErrorTypes__"];
if (!errorTypes) {
errorTypes = Objectfreeze({
CancellationError,
TimeoutError,
OperationalError,
RejectionError: OperationalError,
AggregateError
});
es52.defineProperty(Error, "__BluebirdErrorTypes__", {
value: errorTypes,
writable: false,
enumerable: false,
configurable: false
});
}
module2.exports = {
Error,
TypeError: _TypeError,
RangeError: _RangeError,
CancellationError: errorTypes.CancellationError,
OperationalError: errorTypes.OperationalError,
TimeoutError: errorTypes.TimeoutError,
AggregateError: errorTypes.AggregateError,
Warning
};
}
});
// node_modules/bluebird/js/release/thenables.js
var require_thenables = __commonJS({
"node_modules/bluebird/js/release/thenables.js"(exports2, module2) {
"use strict";
module2.exports = function(Promise2, INTERNAL) {
var util = require_util();
var errorObj2 = util.errorObj;
var isObject2 = util.isObject;
function tryConvertToPromise(obj2, context) {
if (isObject2(obj2)) {
if (obj2 instanceof Promise2) return obj2;
var then = getThen(obj2);
if (then === errorObj2) {
if (context) context._pushContext();
var ret2 = Promise2.reject(then.e);
if (context) context._popContext();
return ret2;
} else if (typeof then === "function") {
if (isAnyBluebirdPromise(obj2)) {
var ret2 = new Promise2(INTERNAL);
obj2._then(
ret2._fulfill,
ret2._reject,
void 0,
ret2,
null
);
return ret2;
}
return doThenable(obj2, then, context);
}
}
return obj2;
}
function doGetThen(obj2) {
return obj2.then;
}
function getThen(obj2) {
try {
return doGetThen(obj2);
} catch (e) {
errorObj2.e = e;
return errorObj2;
}
}
var hasProp = {}.hasOwnProperty;
function isAnyBluebirdPromise(obj2) {
try {
return hasProp.call(obj2, "_promise0");
} catch (e) {
return false;
}
}
function doThenable(x, then, context) {
var promise = new Promise2(INTERNAL);
var ret2 = promise;
if (context) context._pushContext();
promise._captureStackTrace();
if (context) context._popContext();
var synchronous = true;
var result = util.tryCatch(then).call(x, resolve, reject);
synchronous = false;
if (promise && result === errorObj2) {
promise._rejectCallback(result.e, true, true);
promise = null;
}
function resolve(value) {
if (!promise) return;
promise._resolveCallback(value);
promise = null;
}
function reject(reason) {
if (!promise) return;
promise._rejectCallback(reason, synchronous, true);
promise = null;
}
return ret2;
}
return tryConvertToPromise;
};
}
});
// node_modules/bluebird/js/release/promise_array.js
var require_promise_array = __commonJS({
"node_modules/bluebird/js/release/promise_array.js"(exports2, module2) {
"use strict";
module2.exports = function(Promise2, INTERNAL, tryConvertToPromise, apiRejection, Proxyable) {
var util = require_util();
var isArray = util.isArray;
function toResolutionValue(val) {
switch (val) {
case -2:
return [];
case -3:
return {};
case -6:
return /* @__PURE__ */ new Map();
}
}
function PromiseArray(values) {
var promise = this._promise = new Promise2(INTERNAL);
if (values instanceof Promise2) {
promise._propagateFrom(values, 3);
}
promise._setOnCancel(this);
this._values = values;
this._length = 0;
this._totalResolved = 0;
this._init(void 0, -2);
}
util.inherits(PromiseArray, Proxyable);
PromiseArray.prototype.length = function() {
return this._length;
};
PromiseArray.prototype.promise = function() {
return this._promise;
};
PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
var values = tryConvertToPromise(this._values, this._promise);
if (values instanceof Promise2) {
values = values._target();
var bitField = values._bitField;
;
this._values = values;
if ((bitField & 50397184) === 0) {
this._promise._setAsyncGuaranteed();
return values._then(
init,
this._reject,
void 0,
this,
resolveValueIfEmpty
);
} else if ((bitField & 33554432) !== 0) {
values = values._value();
} else if ((bitField & 16777216) !== 0) {
return this._reject(values._reason());
} else {
return this._cancel();
}
}
values = util.asArray(values);
if (values === null) {
var err = apiRejection(
"expecting an array or an iterable object but got " + util.classString(values)
).reason();
this._promise._rejectCallback(err, false);
return;
}
if (values.length === 0) {
if (resolveValueIfEmpty === -5) {
this._resolveEmptyArray();
} else {
this._resolve(toResolutionValue(resolveValueIfEmpty));
}
return;
}
this._iterate(values);
};
PromiseArray.prototype._iterate = function(values) {
var len = this.getActualLength(values.length);
this._length = len;
this._values = this.shouldCopyValues() ? new Array(len) : this._values;
var result = this._promise;
var isResolved = false;
var bitField = null;
for (var i = 0; i < len; ++i) {
var maybePromise = tryConvertToPromise(values[i], result);
if (maybePromise instanceof Promise2) {
maybePromise = maybePromise._target();
bitField = maybePromise._bitField;
} else {
bitField = null;
}
if (isResolved) {
if (bitField !== null) {
maybePromise.suppressUnhandledRejections();
}
} else if (bitField !== null) {
if ((bitField & 50397184) === 0) {
maybePromise._proxy(this, i);
this._values[i] = maybePromise;
} else if ((bitField & 33554432) !== 0) {
isResolved = this._promiseFulfilled(maybePromise._value(), i);
} else if ((bitField & 16777216) !== 0) {
isResolved = this._promiseRejected(maybePromise._reason(), i);
} else {
isResolved = this._promiseCancelled(i);
}
} else {
isResolved = this._promiseFulfilled(maybePromise, i);
}
}
if (!isResolved) result._setAsyncGuaranteed();
};
PromiseArray.prototype._isResolved = function() {
return this._values === null;
};
PromiseArray.prototype._resolve = function(value) {
this._values = null;
this._promise._fulfill(value);
};
PromiseArray.prototype._cancel = function() {
if (this._isResolved() || !this._promise._isCancellable()) return;
this._values = null;
this._promise._cancel();
};
PromiseArray.prototype._reject = function(reason) {
this._values = null;
this._promise._rejectCallback(reason, false);
};
PromiseArray.prototype._promiseFulfilled = function(value, index) {
this._values[index] = value;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
this._resolve(this._values);
return true;
}
return false;
};
PromiseArray.prototype._promiseCancelled = function() {
this._cancel();
return true;
};
PromiseArray.prototype._promiseRejected = function(reason) {
this._totalResolved++;
this._reject(reason);
return true;
};
PromiseArray.prototype._resultCancelled = function() {
if (this._isResolved()) return;
var values = this._values;
this._cancel();
if (values instanceof Promise2) {
values.cancel();
} else {
for (var i = 0; i < values.length; ++i) {
if (values[i] instanceof Promise2) {
values[i].cancel();
}
}
}
};
PromiseArray.prototype.shouldCopyValues = function() {
return true;
};
PromiseArray.prototype.getActualLength = function(len) {
return len;
};
return PromiseArray;
};
}
});
// node_modules/bluebird/js/release/context.js
var require_context = __commonJS({
"node_modules/bluebird/js/release/context.js"(exports2, module2) {
"use strict";
module2.exports = function(Promise2) {
var longStackTraces = false;
var contextStack = [];
Promise2.prototype._promiseCreated = function() {
};
Promise2.prototype._pushContext = function() {
};
Promise2.prototype._popContext = function() {
return null;
};
Promise2._peekContext = Promise2.prototype._peekContext = function() {
};
function Context() {
this._trace = new Context.CapturedTrace(peekContext());
}
Context.prototype._pushContext = function() {
if (this._trace !== void 0) {
this._trace._promiseCreated = null;
contextStack.push(this._trace);
}
};
Context.prototype._popContext = function() {
if (this._trace !== void 0) {
var trace = contextStack.pop();
var ret2 = trace._promiseCreated;
trace._promiseCreated = null;
return ret2;
}
return null;
};
function createContext() {
if (longStackTraces) return new Context();
}
function peekContext() {
var lastIndex = contextStack.length - 1;
if (lastIndex >= 0) {
return contextStack[lastIndex];
}
return void 0;
}
Context.CapturedTrace = null;
Context.create = createContext;
Context.deactivateLongStackTraces = function() {
};
Context.activateLongStackTraces = function() {
var Promise_pushContext = Promise2.prototype._pushContext;
var Promise_popContext = Promise2.prototype._popContext;
var Promise_PeekContext = Promise2._peekContext;
var Promise_peekContext = Promise2.prototype._peekContext;
var Promise_promiseCreated = Promise2.prototype._promiseCreated;
Context.deactivateLongStackTraces = function() {
Promise2.prototype._pushContext = Promise_pushContext;
Promise2.prototype._popContext = Promise_popContext;
Promise2._peekContext = Promise_PeekContext;
Promise2.prototype._peekContext = Promise_peekContext;
Promise2.prototype._promiseCreated = Promise_promiseCreated;
longStackTraces = false;
};
longStackTraces = true;
Promise2.prototype._pushContext = Context.prototype._pushContext;
Promise2.prototype._popContext = Context.prototype._popContext;
Promise2._peekContext = Promise2.prototype._peekContext = peekContext;
Promise2.prototype._promiseCreated = function() {
var ctx = this._peekContext();
if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
};
};
return Context;
};
}
});
// node_modules/bluebird/js/release/debuggability.js
var require_debuggability = __commonJS({
"node_modules/bluebird/js/release/debuggability.js"(exports2, module2) {
"use strict";
module2.exports = function(Promise2, Context) {
var getDomain = Promise2._getDomain;
var async = Promise2._async;
var Warning = require_errors().Warning;
var util = require_util();
var canAttachTrace2 = util.canAttachTrace;
var unhandledRejectionHandled;
var possiblyUnhandledRejection;
var bluebirdFramePattern = /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/;
var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/;
var stackFramePattern = null;
var formatStack = null;
var indentStackFrames = false;
var printWarning;
var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 && (util.env("BLUEBIRD_DEBUG") || util.env("NODE_ENV") === "development"));
var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 && (debugging || util.env("BLUEBIRD_WARNINGS")));
var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 && (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 && (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
Promise2.prototype.suppressUnhandledRejections = function() {
var target = this._target();
target._bitField = target._bitField & ~1048576 | 524288;
};
Promise2.prototype._ensurePossibleRejectionHandled = function() {
if ((this._bitField & 524288) !== 0) return;
this._setRejectionIsUnhandled();
var self2 = this;
setTimeout(function() {
self2._notifyUnhandledRejection();
}, 1);
};
Promise2.prototype._notifyUnhandledRejectionIsHandled = function() {
fireRejectionEvent(
"rejectionHandled",
unhandledRejectionHandled,
void 0,
this
);
};
Promise2.prototype._setReturnedNonUndefined = function() {
this._bitField = this._bitField | 268435456;
};
Promise2.prototype._returnedNonUndefined = function() {
return (this._bitField & 268435456) !== 0;
};
Promise2.prototype._notifyUnhandledRejection = function() {
if (this._isRejectionUnhandled()) {
var reason = this._settledValue();
this._setUnhandledRejectionIsNotified();
fireRejectionEvent(
"unhandledRejection",
possiblyUnhandledRejection,
reason,
this
);
}
};
Promise2.prototype._setUnhandledRejectionIsNotified = function() {
this._bitField = this._bitField | 262144;
};
Promise2.prototype._unsetUnhandledRejectionIsNotified = function() {
this._bitField = this._bitField & ~262144;
};
Promise2.prototype._isUnhandledRejectionNotified = function() {
return (this._bitField & 262144) > 0;
};
Promise2.prototype._setRejectionIsUnhandled = function() {
this._bitField = this._bitField | 1048576;
};
Promise2.prototype._unsetRejectionIsUnhandled = function() {
this._bitField = this._bitField & ~1048576;
if (this._isUnhandledRejectionNotified()) {
this._unsetUnhandledRejectionIsNotified();
this._notifyUnhandledRejectionIsHandled();
}
};
Promise2.prototype._isRejectionUnhandled = function() {
return (this._bitField & 1048576) > 0;
};
Promise2.prototype._warn = function(message, shouldUseOwnTrace, promise) {
return warn(message, shouldUseOwnTrace, promise || this);
};
Promise2.onPossiblyUnhandledRejection = function(fn) {
var domain = getDomain();
possiblyUnhandledRejection = typeof fn === "function" ? domain === null ? fn : util.domainBind(domain, fn) : void 0;
};
Promise2.onUnhandledRejectionHandled = function(fn) {
var domain = getDomain();
unhandledRejectionHandled = typeof fn === "function" ? domain === null ? fn : util.domainBind(domain, fn) : void 0;
};
var disableLongStackTraces = function() {
};
Promise2.longStackTraces = function() {
if (async.haveItemsQueued() && !config.longStackTraces) {
throw new Error("cannot enable long stack traces after promises have been created\n\n See http://goo.gl/MqrFmX\n");
}
if (!config.longStackTraces && longStackTracesIsSupported()) {
var Promise_captureStackTrace = Promise2.prototype._captureStackTrace;
var Promise_attachExtraTrace = Promise2.prototype._attachExtraTrace;
config.longStackTraces = true;
disableLongStackTraces = function() {
if (async.haveItemsQueued() && !config.longStackTraces) {
throw new Error("cannot enable long stack traces after promises have been created\n\n See http://goo.gl/MqrFmX\n");
}
Promise2.prototype._captureStackTrace = Promise_captureStackTrace;
Promise2.prototype._attachExtraTrace = Promise_attachExtraTrace;
Context.deactivateLongStackTraces();
async.enableTrampoline();
config.longStackTraces = false;
};
Promise2.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
Promise2.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
Context.activateLongStackTraces();
async.disableTrampolineIfNecessary();
}
};
Promise2.hasLongStackTraces = function() {
return config.longStackTraces && longStackTracesIsSupported();
};
var fireDomEvent = function() {
try {
if (typeof CustomEvent === "function") {
var event = new CustomEvent("CustomEvent");
util.global.dispatchEvent(event);
return function(name, event2) {
var domEvent = new CustomEvent(name.toLowerCase(), {
detail: event2,
cancelable: true
});
return !util.global.dispatchEvent(domEvent);
};
} else if (typeof Event === "function") {
var event = new Event("CustomEvent");
util.global.dispatchEvent(event);
return function(name, event2) {
var domEvent = new Event(name.toLowerCase(), {
cancelable: true
});
domEvent.detail = event2;
return !util.global.dispatchEvent(domEvent);
};
} else {
var event = document.createEvent("CustomEvent");
event.initCustomEvent("testingtheevent", false, true, {});
util.global.dispatchEvent(event);
return function(name, event2) {
var domEvent = document.createEvent("CustomEvent");
domEvent.initCustomEvent(
name.toLowerCase(),
false,
true,
event2
);
return !util.global.dispatchEvent(domEvent);
};
}
} catch (e) {
}
return function() {
return false;
};
}();
var fireGlobalEvent = function() {
if (util.isNode) {
return function() {
return process.emit.apply(process, arguments);
};
} else {
if (!util.global) {
return function() {
return false;
};
}
return function(name) {
var methodName = "on" + name.toLowerCase();
var method = util.global[methodName];
if (!method) return false;
method.apply(util.global, [].slice.call(arguments, 1));
return true;
};
}
}();
function generatePromiseLifecycleEventObject(name, promise) {
return { promise };
}
var eventToObjectGenerator = {
promiseCreated: generatePromiseLifecycleEventObject,
promiseFulfilled: generatePromiseLifecycleEventObject,
promiseRejected: generatePromiseLifecycleEventObject,
promiseResolved: generatePromiseLifecycleEventObject,
promiseCancelled: generatePromiseLifecycleEventObject,
promiseChained: function(name, promise, child) {
return { promise, child };
},
warning: function(name, warning) {
return { warning };
},
unhandledRejection: function(name, reason, promise) {
return { reason, promise };
},
rejectionHandled: generatePromiseLifecycleEventObject
};
var activeFireEvent = function(name) {
var globalEventFired = false;
try {
globalEventFired = fireGlobalEvent.apply(null, arguments);
} catch (e) {
async.throwLater(e);
globalEventFired = true;
}
var domEventFired = false;
try {
domEventFired = fireDomEvent(
name,
eventToObjectGenerator[name].apply(null, arguments)
);
} catch (e) {
async.throwLater(e);
domEventFired = true;
}
return domEventFired || globalEventFired;
};
Promise2.config = function(opts) {
opts = Object(opts);
if ("longStackTraces" in opts) {
if (opts.longStackTraces) {
Promise2.longStackTraces();
} else if (!opts.longStackTraces && Promise2.hasLongStackTraces()) {
disableLongStackTraces();
}
}
if ("warnings" in opts) {
var warningsOption = opts.warnings;
config.warnings = !!warningsOption;
wForgottenReturn = config.warnings;
if (util.isObject(warningsOption)) {
if ("wForgottenReturn" in warningsOption) {
wForgottenReturn = !!warningsOption.wForgottenReturn;
}
}
}
if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
if (async.haveItemsQueued()) {
throw new Error(
"cannot enable cancellation after promises are in use"
);
}
Promise2.prototype._clearCancellationData = cancellationClearCancellationData;
Promise2.prototype._propagateFrom = cancellationPropagateFrom;
Promise2.prototype._onCancel = cancellationOnCancel;
Promise2.prototype._setOnCancel = cancellationSetOnCancel;
Promise2.prototype._attachCancellationCallback = cancellationAttachCancellationCallback;
Promise2.prototype._execute = cancellationExecute;
propagateFromFunction = cancellationPropagateFrom;
config.cancellation = true;
}
if ("monitoring" in opts) {
if (opts.monitoring && !config.monitoring) {
config.monitoring = true;
Promise2.prototype._fireEvent = activeFireEvent;
} else if (!opts.monitoring && config.monitoring) {
config.monitoring = false;
Promise2.prototype._fireEvent = defaultFireEvent;
}
}
return Promise2;
};
function defaultFireEvent() {
return false;
}
Promise2.prototype._fireEvent = defaultFireEvent;
Promise2.prototype._execute = function(executor, resolve, reject) {
try {
executor(resolve, reject);
} catch (e) {
return e;
}
};
Promise2.prototype._onCancel = function() {
};
Promise2.prototype._setOnCancel = function(handler) {
;
};
Promise2.p