417 lines
11 KiB
JavaScript
417 lines
11 KiB
JavaScript
/* */
|
|
"format global";
|
|
(function (global) {
|
|
var babelHelpers = global.babelHelpers = {};
|
|
|
|
babelHelpers.inherits = function (subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) subClass.__proto__ = superClass;
|
|
};
|
|
|
|
babelHelpers.defaults = function (obj, defaults) {
|
|
var keys = Object.getOwnPropertyNames(defaults);
|
|
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
var value = Object.getOwnPropertyDescriptor(defaults, key);
|
|
|
|
if (value && value.configurable && obj[key] === undefined) {
|
|
Object.defineProperty(obj, key, value);
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
babelHelpers.createClass = (function () {
|
|
function defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
|
|
return function (Constructor, protoProps, staticProps) {
|
|
if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
};
|
|
})();
|
|
|
|
babelHelpers.createDecoratedClass = (function () {
|
|
function defineProperties(target, descriptors, initializers) {
|
|
for (var i = 0; i < descriptors.length; i++) {
|
|
var descriptor = descriptors[i];
|
|
var decorators = descriptor.decorators;
|
|
var key = descriptor.key;
|
|
delete descriptor.key;
|
|
delete descriptor.decorators;
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor || descriptor.initializer) descriptor.writable = true;
|
|
|
|
if (decorators) {
|
|
for (var f = 0; f < decorators.length; f++) {
|
|
var decorator = decorators[f];
|
|
|
|
if (typeof decorator === "function") {
|
|
descriptor = decorator(target, key, descriptor) || descriptor;
|
|
} else {
|
|
throw new TypeError("The decorator for method " + descriptor.key + " is of the invalid type " + typeof decorator);
|
|
}
|
|
}
|
|
|
|
if (descriptor.initializer !== undefined) {
|
|
initializers[key] = descriptor;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(target, key, descriptor);
|
|
}
|
|
}
|
|
|
|
return function (Constructor, protoProps, staticProps, protoInitializers, staticInitializers) {
|
|
if (protoProps) defineProperties(Constructor.prototype, protoProps, protoInitializers);
|
|
if (staticProps) defineProperties(Constructor, staticProps, staticInitializers);
|
|
return Constructor;
|
|
};
|
|
})();
|
|
|
|
babelHelpers.createDecoratedObject = function (descriptors) {
|
|
var target = {};
|
|
|
|
for (var i = 0; i < descriptors.length; i++) {
|
|
var descriptor = descriptors[i];
|
|
var decorators = descriptor.decorators;
|
|
var key = descriptor.key;
|
|
delete descriptor.key;
|
|
delete descriptor.decorators;
|
|
descriptor.enumerable = true;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor || descriptor.initializer) descriptor.writable = true;
|
|
|
|
if (decorators) {
|
|
for (var f = 0; f < decorators.length; f++) {
|
|
var decorator = decorators[f];
|
|
|
|
if (typeof decorator === "function") {
|
|
descriptor = decorator(target, key, descriptor) || descriptor;
|
|
} else {
|
|
throw new TypeError("The decorator for method " + descriptor.key + " is of the invalid type " + typeof decorator);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (descriptor.initializer) {
|
|
descriptor.value = descriptor.initializer.call(target);
|
|
}
|
|
|
|
Object.defineProperty(target, key, descriptor);
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
babelHelpers.defineDecoratedPropertyDescriptor = function (target, key, descriptors) {
|
|
var _descriptor = descriptors[key];
|
|
if (!_descriptor) return;
|
|
var descriptor = {};
|
|
|
|
for (var _key in _descriptor) descriptor[_key] = _descriptor[_key];
|
|
|
|
descriptor.value = descriptor.initializer.call(target);
|
|
Object.defineProperty(target, key, descriptor);
|
|
};
|
|
|
|
babelHelpers.taggedTemplateLiteral = function (strings, raw) {
|
|
return Object.freeze(Object.defineProperties(strings, {
|
|
raw: {
|
|
value: Object.freeze(raw)
|
|
}
|
|
}));
|
|
};
|
|
|
|
babelHelpers.taggedTemplateLiteralLoose = function (strings, raw) {
|
|
strings.raw = raw;
|
|
return strings;
|
|
};
|
|
|
|
babelHelpers.toArray = function (arr) {
|
|
return Array.isArray(arr) ? arr : Array.from(arr);
|
|
};
|
|
|
|
babelHelpers.toConsumableArray = function (arr) {
|
|
if (Array.isArray(arr)) {
|
|
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
|
|
|
|
return arr2;
|
|
} else {
|
|
return Array.from(arr);
|
|
}
|
|
};
|
|
|
|
babelHelpers.slicedToArray = (function () {
|
|
function sliceIterator(arr, i) {
|
|
var _arr = [];
|
|
var _n = true;
|
|
var _d = false;
|
|
var _e = undefined;
|
|
|
|
try {
|
|
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
|
|
_arr.push(_s.value);
|
|
|
|
if (i && _arr.length === i) break;
|
|
}
|
|
} catch (err) {
|
|
_d = true;
|
|
_e = err;
|
|
} finally {
|
|
try {
|
|
if (!_n && _i["return"]) _i["return"]();
|
|
} finally {
|
|
if (_d) throw _e;
|
|
}
|
|
}
|
|
|
|
return _arr;
|
|
}
|
|
|
|
return function (arr, i) {
|
|
if (Array.isArray(arr)) {
|
|
return arr;
|
|
} else if (Symbol.iterator in Object(arr)) {
|
|
return sliceIterator(arr, i);
|
|
} else {
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance");
|
|
}
|
|
};
|
|
})();
|
|
|
|
babelHelpers.slicedToArrayLoose = function (arr, i) {
|
|
if (Array.isArray(arr)) {
|
|
return arr;
|
|
} else if (Symbol.iterator in Object(arr)) {
|
|
var _arr = [];
|
|
|
|
for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
|
|
_arr.push(_step.value);
|
|
|
|
if (i && _arr.length === i) break;
|
|
}
|
|
|
|
return _arr;
|
|
} else {
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance");
|
|
}
|
|
};
|
|
|
|
babelHelpers.objectWithoutProperties = function (obj, keys) {
|
|
var target = {};
|
|
|
|
for (var i in obj) {
|
|
if (keys.indexOf(i) >= 0) continue;
|
|
if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
|
|
target[i] = obj[i];
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
babelHelpers.hasOwn = Object.prototype.hasOwnProperty;
|
|
babelHelpers.slice = Array.prototype.slice;
|
|
babelHelpers.bind = Function.prototype.bind;
|
|
|
|
babelHelpers.defineProperty = function (obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
babelHelpers.asyncToGenerator = function (fn) {
|
|
return function () {
|
|
var gen = fn.apply(this, arguments);
|
|
return new Promise(function (resolve, reject) {
|
|
var callNext = step.bind(null, "next");
|
|
var callThrow = step.bind(null, "throw");
|
|
|
|
function step(key, arg) {
|
|
try {
|
|
var info = gen[key](arg);
|
|
var value = info.value;
|
|
} catch (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
|
|
if (info.done) {
|
|
resolve(value);
|
|
} else {
|
|
Promise.resolve(value).then(callNext, callThrow);
|
|
}
|
|
}
|
|
|
|
callNext();
|
|
});
|
|
};
|
|
};
|
|
|
|
babelHelpers.interopRequireWildcard = function (obj) {
|
|
if (obj && obj.__esModule) {
|
|
return obj;
|
|
} else {
|
|
var newObj = {};
|
|
|
|
if (obj != null) {
|
|
for (var key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
|
|
}
|
|
}
|
|
|
|
newObj["default"] = obj;
|
|
return newObj;
|
|
}
|
|
};
|
|
|
|
babelHelpers.interopRequireDefault = function (obj) {
|
|
return obj && obj.__esModule ? obj : {
|
|
"default": obj
|
|
};
|
|
};
|
|
|
|
babelHelpers._typeof = function (obj) {
|
|
return obj && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
};
|
|
|
|
babelHelpers._extends = Object.assign || function (target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
babelHelpers.get = function get(object, property, receiver) {
|
|
if (object === null) object = Function.prototype;
|
|
var desc = Object.getOwnPropertyDescriptor(object, property);
|
|
|
|
if (desc === undefined) {
|
|
var parent = Object.getPrototypeOf(object);
|
|
|
|
if (parent === null) {
|
|
return undefined;
|
|
} else {
|
|
return get(parent, property, receiver);
|
|
}
|
|
} else if ("value" in desc) {
|
|
return desc.value;
|
|
} else {
|
|
var getter = desc.get;
|
|
|
|
if (getter === undefined) {
|
|
return undefined;
|
|
}
|
|
|
|
return getter.call(receiver);
|
|
}
|
|
};
|
|
|
|
babelHelpers.set = function set(object, property, value, receiver) {
|
|
var desc = Object.getOwnPropertyDescriptor(object, property);
|
|
|
|
if (desc === undefined) {
|
|
var parent = Object.getPrototypeOf(object);
|
|
|
|
if (parent !== null) {
|
|
set(parent, property, value, receiver);
|
|
}
|
|
} else if ("value" in desc && desc.writable) {
|
|
desc.value = value;
|
|
} else {
|
|
var setter = desc.set;
|
|
|
|
if (setter !== undefined) {
|
|
setter.call(receiver, value);
|
|
}
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
babelHelpers.classCallCheck = function (instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
};
|
|
|
|
babelHelpers.objectDestructuringEmpty = function (obj) {
|
|
if (obj == null) throw new TypeError("Cannot destructure undefined");
|
|
};
|
|
|
|
babelHelpers.temporalUndefined = {};
|
|
|
|
babelHelpers.temporalAssertDefined = function (val, name, undef) {
|
|
if (val === undef) {
|
|
throw new ReferenceError(name + " is not defined - temporal dead zone");
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
babelHelpers.selfGlobal = typeof global === "undefined" ? self : global;
|
|
|
|
babelHelpers.defaultProps = function (defaultProps, props) {
|
|
if (defaultProps) {
|
|
for (var propName in defaultProps) {
|
|
if (typeof props[propName] === "undefined") {
|
|
props[propName] = defaultProps[propName];
|
|
}
|
|
}
|
|
}
|
|
|
|
return props;
|
|
};
|
|
|
|
babelHelpers._instanceof = function (left, right) {
|
|
if (right != null && right[Symbol.hasInstance]) {
|
|
return right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
};
|
|
|
|
babelHelpers.interopRequire = function (obj) {
|
|
return obj && obj.__esModule ? obj["default"] : obj;
|
|
};
|
|
})(typeof global === "undefined" ? self : global);
|