652 lines
17 KiB
JavaScript
652 lines
17 KiB
JavaScript
/* eslint max-len: "off" */
|
|
|
|
import template from "@babel/template";
|
|
|
|
const helpers = {};
|
|
export default helpers;
|
|
|
|
function defineHelper(str) {
|
|
return template(str, { sourceType: "module" });
|
|
}
|
|
|
|
helpers.typeof = defineHelper(`
|
|
export default function _typeof(obj) {
|
|
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
|
_typeof = function (obj) { return typeof obj; };
|
|
} else {
|
|
_typeof = function (obj) {
|
|
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype
|
|
? "symbol"
|
|
: typeof obj;
|
|
};
|
|
}
|
|
|
|
return _typeof(obj);
|
|
}
|
|
`);
|
|
|
|
helpers.jsx = defineHelper(`
|
|
var REACT_ELEMENT_TYPE;
|
|
|
|
export default function _createRawReactElement(type, props, key, children) {
|
|
if (!REACT_ELEMENT_TYPE) {
|
|
REACT_ELEMENT_TYPE = (typeof Symbol === "function" && Symbol.for && Symbol.for("react.element")) || 0xeac7;
|
|
}
|
|
|
|
var defaultProps = type && type.defaultProps;
|
|
var childrenLength = arguments.length - 3;
|
|
|
|
if (!props && childrenLength !== 0) {
|
|
// If we're going to assign props.children, we create a new object now
|
|
// to avoid mutating defaultProps.
|
|
props = {};
|
|
}
|
|
if (props && defaultProps) {
|
|
for (var propName in defaultProps) {
|
|
if (props[propName] === void 0) {
|
|
props[propName] = defaultProps[propName];
|
|
}
|
|
}
|
|
} else if (!props) {
|
|
props = defaultProps || {};
|
|
}
|
|
|
|
if (childrenLength === 1) {
|
|
props.children = children;
|
|
} else if (childrenLength > 1) {
|
|
var childArray = new Array(childrenLength);
|
|
for (var i = 0; i < childrenLength; i++) {
|
|
childArray[i] = arguments[i + 3];
|
|
}
|
|
props.children = childArray;
|
|
}
|
|
|
|
return {
|
|
$$typeof: REACT_ELEMENT_TYPE,
|
|
type: type,
|
|
key: key === undefined ? null : '' + key,
|
|
ref: null,
|
|
props: props,
|
|
_owner: null,
|
|
};
|
|
}
|
|
`);
|
|
|
|
helpers.asyncIterator = defineHelper(`
|
|
export default function _asyncIterator(iterable) {
|
|
if (typeof Symbol === "function") {
|
|
if (Symbol.asyncIterator) {
|
|
var method = iterable[Symbol.asyncIterator];
|
|
if (method != null) return method.call(iterable);
|
|
}
|
|
if (Symbol.iterator) {
|
|
return iterable[Symbol.iterator]();
|
|
}
|
|
}
|
|
throw new TypeError("Object is not async iterable");
|
|
}
|
|
`);
|
|
|
|
helpers.asyncGenerator = defineHelper(`
|
|
function AwaitValue(value) {
|
|
this.value = value;
|
|
}
|
|
|
|
function AsyncGenerator(gen) {
|
|
var front, back;
|
|
|
|
function send(key, arg) {
|
|
return new Promise(function (resolve, reject) {
|
|
var request = {
|
|
key: key,
|
|
arg: arg,
|
|
resolve: resolve,
|
|
reject: reject,
|
|
next: null
|
|
};
|
|
|
|
if (back) {
|
|
back = back.next = request;
|
|
} else {
|
|
front = back = request;
|
|
resume(key, arg);
|
|
}
|
|
});
|
|
}
|
|
|
|
function resume(key, arg) {
|
|
try {
|
|
var result = gen[key](arg)
|
|
var value = result.value;
|
|
if (value instanceof AwaitValue) {
|
|
Promise.resolve(value.value).then(
|
|
function (arg) { resume("next", arg); },
|
|
function (arg) { resume("throw", arg); });
|
|
} else {
|
|
settle(result.done ? "return" : "normal", result.value);
|
|
}
|
|
} catch (err) {
|
|
settle("throw", err);
|
|
}
|
|
}
|
|
|
|
function settle(type, value) {
|
|
switch (type) {
|
|
case "return":
|
|
front.resolve({ value: value, done: true });
|
|
break;
|
|
case "throw":
|
|
front.reject(value);
|
|
break;
|
|
default:
|
|
front.resolve({ value: value, done: false });
|
|
break;
|
|
}
|
|
|
|
front = front.next;
|
|
if (front) {
|
|
resume(front.key, front.arg);
|
|
} else {
|
|
back = null;
|
|
}
|
|
}
|
|
|
|
this._invoke = send;
|
|
|
|
// Hide "return" method if generator return is not supported
|
|
if (typeof gen.return !== "function") {
|
|
this.return = undefined;
|
|
}
|
|
}
|
|
|
|
if (typeof Symbol === "function" && Symbol.asyncIterator) {
|
|
AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; };
|
|
}
|
|
|
|
AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
|
|
AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };
|
|
AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
|
|
|
|
export default {
|
|
wrap: function (fn) {
|
|
return function () {
|
|
return new AsyncGenerator(fn.apply(this, arguments));
|
|
};
|
|
},
|
|
await: function (value) {
|
|
return new AwaitValue(value);
|
|
}
|
|
};
|
|
`);
|
|
|
|
helpers.asyncGeneratorDelegate = defineHelper(`
|
|
export default function _asyncGeneratorDelegate(inner, awaitWrap) {
|
|
var iter = {}, waiting = false;
|
|
|
|
function pump(key, value) {
|
|
waiting = true;
|
|
value = new Promise(function (resolve) { resolve(inner[key](value)); });
|
|
return { done: false, value: awaitWrap(value) };
|
|
};
|
|
|
|
if (typeof Symbol === "function" && Symbol.iterator) {
|
|
iter[Symbol.iterator] = function () { return this; };
|
|
}
|
|
|
|
iter.next = function (value) {
|
|
if (waiting) {
|
|
waiting = false;
|
|
return value;
|
|
}
|
|
return pump("next", value);
|
|
};
|
|
|
|
if (typeof inner.throw === "function") {
|
|
iter.throw = function (value) {
|
|
if (waiting) {
|
|
waiting = false;
|
|
throw value;
|
|
}
|
|
return pump("throw", value);
|
|
};
|
|
}
|
|
|
|
if (typeof inner.return === "function") {
|
|
iter.return = function (value) {
|
|
return pump("return", value);
|
|
};
|
|
}
|
|
|
|
return iter;
|
|
}
|
|
`);
|
|
|
|
helpers.asyncToGenerator = defineHelper(`
|
|
export default function _asyncToGenerator(fn) {
|
|
return function () {
|
|
var self = this, args = arguments;
|
|
return new Promise(function (resolve, reject) {
|
|
var gen = fn.apply(self, args);
|
|
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(_next, _throw);
|
|
}
|
|
}
|
|
function _next(value) { step("next", value); }
|
|
function _throw(err) { step("throw", err); }
|
|
|
|
_next();
|
|
});
|
|
};
|
|
}
|
|
`);
|
|
|
|
helpers.classCallCheck = defineHelper(`
|
|
export default function _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.createClass = defineHelper(`
|
|
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);
|
|
}
|
|
}
|
|
|
|
export default function _createClass(Constructor, protoProps, staticProps) {
|
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) _defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
}
|
|
`);
|
|
|
|
helpers.defineEnumerableProperties = defineHelper(`
|
|
export default function _defineEnumerableProperties(obj, descs) {
|
|
for (var key in descs) {
|
|
var desc = descs[key];
|
|
desc.configurable = desc.enumerable = true;
|
|
if ("value" in desc) desc.writable = true;
|
|
Object.defineProperty(obj, key, desc);
|
|
}
|
|
|
|
// Symbols are not enumerated over by for-in loops. If native
|
|
// Symbols are available, fetch all of the descs object's own
|
|
// symbol properties and define them on our target object too.
|
|
if (Object.getOwnPropertySymbols) {
|
|
var objectSymbols = Object.getOwnPropertySymbols(descs);
|
|
for (var i = 0; i < objectSymbols.length; i++) {
|
|
var sym = objectSymbols[i];
|
|
var desc = descs[sym];
|
|
desc.configurable = desc.enumerable = true;
|
|
if ("value" in desc) desc.writable = true;
|
|
Object.defineProperty(obj, sym, desc);
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
`);
|
|
|
|
helpers.defaults = defineHelper(`
|
|
export default function _defaults(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;
|
|
}
|
|
`);
|
|
|
|
helpers.defineProperty = defineHelper(`
|
|
export default function _defineProperty(obj, key, value) {
|
|
// Shortcircuit the slow defineProperty path when possible.
|
|
// We are trying to avoid issues where setters defined on the
|
|
// prototype cause side effects under the fast path of simple
|
|
// assignment. By checking for existence of the property with
|
|
// the in operator, we can optimize most of this overhead away.
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
`);
|
|
|
|
helpers.extends = defineHelper(`
|
|
export default function _extends() {
|
|
_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;
|
|
};
|
|
|
|
return _extends.apply(this, arguments);
|
|
}
|
|
`);
|
|
|
|
helpers.get = defineHelper(`
|
|
export default 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);
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.inherits = defineHelper(`
|
|
export default function _inherits(subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
|
}
|
|
`);
|
|
|
|
helpers.inheritsLoose = defineHelper(`
|
|
export default function _inheritsLoose(subClass, superClass) {
|
|
subClass.prototype = Object.create(superClass.prototype);
|
|
subClass.prototype.constructor = subClass;
|
|
subClass.__proto__ = superClass;
|
|
}
|
|
`);
|
|
|
|
helpers.instanceof = defineHelper(`
|
|
export default function _instanceof(left, right) {
|
|
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
|
return right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.interopRequireDefault = defineHelper(`
|
|
export default function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
`);
|
|
|
|
helpers.interopRequireWildcard = defineHelper(`
|
|
export default function _interopRequireWildcard(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;
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.newArrowCheck = defineHelper(`
|
|
export default function _newArrowCheck(innerThis, boundThis) {
|
|
if (innerThis !== boundThis) {
|
|
throw new TypeError("Cannot instantiate an arrow function");
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.objectDestructuringEmpty = defineHelper(`
|
|
export default function _objectDestructuringEmpty(obj) {
|
|
if (obj == null) throw new TypeError("Cannot destructure undefined");
|
|
}
|
|
`);
|
|
|
|
helpers.objectWithoutProperties = defineHelper(`
|
|
export default function _objectWithoutProperties(source, excluded) {
|
|
if (source == null) return {};
|
|
|
|
var target = {};
|
|
var sourceKeys = Object.keys(source);
|
|
var key, i;
|
|
|
|
for (i = 0; i < sourceKeys.length; i++) {
|
|
key = sourceKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
target[key] = source[key];
|
|
}
|
|
|
|
if (Object.getOwnPropertySymbols) {
|
|
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
|
for (i = 0; i < sourceSymbolKeys.length; i++) {
|
|
key = sourceSymbolKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
`);
|
|
|
|
helpers.possibleConstructorReturn = defineHelper(`
|
|
export default function _possibleConstructorReturn(self, call) {
|
|
if (call && (typeof call === "object" || typeof call === "function")) {
|
|
return call;
|
|
}
|
|
if (!self) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
return self;
|
|
}
|
|
`);
|
|
|
|
helpers.set = defineHelper(`
|
|
export default 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;
|
|
}
|
|
`);
|
|
|
|
helpers.slicedToArray = defineHelper(`
|
|
// Broken out into a separate function to avoid deoptimizations due to the try/catch for the
|
|
// array iterator case.
|
|
function _sliceIterator(arr, i) {
|
|
// this is an expanded form of \`for...of\` that properly supports abrupt completions of
|
|
// iterators etc. variable names have been minimised to reduce the size of this massive
|
|
// helper. sometimes spec compliancy is annoying :(
|
|
//
|
|
// _n = _iteratorNormalCompletion
|
|
// _d = _didIteratorError
|
|
// _e = _iteratorError
|
|
// _i = _iterator
|
|
// _s = _step
|
|
|
|
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"] != null) _i["return"]();
|
|
} finally {
|
|
if (_d) throw _e;
|
|
}
|
|
}
|
|
return _arr;
|
|
}
|
|
|
|
export default function _slicedToArray(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");
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.slicedToArrayLoose = defineHelper(`
|
|
export default function _slicedToArrayLoose(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");
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.taggedTemplateLiteral = defineHelper(`
|
|
export default function _taggedTemplateLiteral(strings, raw) {
|
|
return Object.freeze(Object.defineProperties(strings, {
|
|
raw: { value: Object.freeze(raw) }
|
|
}));
|
|
}
|
|
`);
|
|
|
|
helpers.taggedTemplateLiteralLoose = defineHelper(`
|
|
export default function _taggedTemplateLiteralLoose(strings, raw) {
|
|
strings.raw = raw;
|
|
return strings;
|
|
}
|
|
`);
|
|
|
|
helpers.temporalRef = defineHelper(`
|
|
export default function _temporalRef(val, name, undef) {
|
|
if (val === undef) {
|
|
throw new ReferenceError(name + " is not defined - temporal dead zone");
|
|
} else {
|
|
return val;
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.temporalUndefined = defineHelper(`
|
|
export default {};
|
|
`);
|
|
|
|
helpers.toArray = defineHelper(`
|
|
export default function _toArray(arr) {
|
|
return Array.isArray(arr) ? arr : Array.from(arr);
|
|
}
|
|
`);
|
|
|
|
helpers.toConsumableArray = defineHelper(`
|
|
export default function _toConsumableArray(arr) {
|
|
if (Array.isArray(arr)) {
|
|
for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
|
|
return arr2;
|
|
} else {
|
|
return Array.from(arr);
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.skipFirstGeneratorNext = defineHelper(`
|
|
export default function _skipFirstGeneratorNext(fn) {
|
|
return function () {
|
|
var it = fn.apply(this, arguments);
|
|
it.next();
|
|
return it;
|
|
}
|
|
}
|
|
`);
|
|
|
|
helpers.toPropertyKey = defineHelper(`
|
|
export default function _toPropertyKey(key) {
|
|
if (typeof key === "symbol") {
|
|
return key;
|
|
} else {
|
|
return String(key);
|
|
}
|
|
}
|
|
`);
|