1 |
|
2 | var babelHelpers = {};
|
3 | babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
4 | return typeof obj;
|
5 | } : function (obj) {
|
6 | return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
7 | };
|
8 |
|
9 | babelHelpers.jsx = function () {
|
10 | var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
|
11 | return function createRawReactElement(type, props, key, children) {
|
12 | var defaultProps = type && type.defaultProps;
|
13 | var childrenLength = arguments.length - 3;
|
14 |
|
15 | if (!props && childrenLength !== 0) {
|
16 | props = {};
|
17 | }
|
18 |
|
19 | if (props && defaultProps) {
|
20 | for (var propName in defaultProps) {
|
21 | if (props[propName] === void 0) {
|
22 | props[propName] = defaultProps[propName];
|
23 | }
|
24 | }
|
25 | } else if (!props) {
|
26 | props = defaultProps || {};
|
27 | }
|
28 |
|
29 | if (childrenLength === 1) {
|
30 | props.children = children;
|
31 | } else if (childrenLength > 1) {
|
32 | var childArray = Array(childrenLength);
|
33 |
|
34 | for (var i = 0; i < childrenLength; i++) {
|
35 | childArray[i] = arguments[i + 3];
|
36 | }
|
37 |
|
38 | props.children = childArray;
|
39 | }
|
40 |
|
41 | return {
|
42 | $$typeof: REACT_ELEMENT_TYPE,
|
43 | type: type,
|
44 | key: key === undefined ? null : '' + key,
|
45 | ref: null,
|
46 | props: props,
|
47 | _owner: null
|
48 | };
|
49 | };
|
50 | }();
|
51 |
|
52 | babelHelpers.asyncToGenerator = function (fn) {
|
53 | return function () {
|
54 | var gen = fn.apply(this, arguments);
|
55 | return new Promise(function (resolve, reject) {
|
56 | function step(key, arg) {
|
57 | try {
|
58 | var info = gen[key](arg);
|
59 | var value = info.value;
|
60 | } catch (error) {
|
61 | reject(error);
|
62 | return;
|
63 | }
|
64 |
|
65 | if (info.done) {
|
66 | resolve(value);
|
67 | } else {
|
68 | return Promise.resolve(value).then(function (value) {
|
69 | return step("next", value);
|
70 | }, function (err) {
|
71 | return step("throw", err);
|
72 | });
|
73 | }
|
74 | }
|
75 |
|
76 | return step("next");
|
77 | });
|
78 | };
|
79 | };
|
80 |
|
81 | babelHelpers.classCallCheck = function (instance, Constructor) {
|
82 | if (!(instance instanceof Constructor)) {
|
83 | throw new TypeError("Cannot call a class as a function");
|
84 | }
|
85 | };
|
86 |
|
87 | babelHelpers.createClass = function () {
|
88 | function defineProperties(target, props) {
|
89 | for (var i = 0; i < props.length; i++) {
|
90 | var descriptor = props[i];
|
91 | descriptor.enumerable = descriptor.enumerable || false;
|
92 | descriptor.configurable = true;
|
93 | if ("value" in descriptor) descriptor.writable = true;
|
94 | Object.defineProperty(target, descriptor.key, descriptor);
|
95 | }
|
96 | }
|
97 |
|
98 | return function (Constructor, protoProps, staticProps) {
|
99 | if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
100 | if (staticProps) defineProperties(Constructor, staticProps);
|
101 | return Constructor;
|
102 | };
|
103 | }();
|
104 |
|
105 | babelHelpers.defineEnumerableProperties = function (obj, descs) {
|
106 | for (var key in descs) {
|
107 | var desc = descs[key];
|
108 | desc.configurable = desc.enumerable = true;
|
109 | if ("value" in desc) desc.writable = true;
|
110 | Object.defineProperty(obj, key, desc);
|
111 | }
|
112 |
|
113 | return obj;
|
114 | };
|
115 |
|
116 | babelHelpers.defaults = function (obj, defaults) {
|
117 | var keys = Object.getOwnPropertyNames(defaults);
|
118 |
|
119 | for (var i = 0; i < keys.length; i++) {
|
120 | var key = keys[i];
|
121 | var value = Object.getOwnPropertyDescriptor(defaults, key);
|
122 |
|
123 | if (value && value.configurable && obj[key] === undefined) {
|
124 | Object.defineProperty(obj, key, value);
|
125 | }
|
126 | }
|
127 |
|
128 | return obj;
|
129 | };
|
130 |
|
131 | babelHelpers.defineProperty = function (obj, key, value) {
|
132 | if (key in obj) {
|
133 | Object.defineProperty(obj, key, {
|
134 | value: value,
|
135 | enumerable: true,
|
136 | configurable: true,
|
137 | writable: true
|
138 | });
|
139 | } else {
|
140 | obj[key] = value;
|
141 | }
|
142 |
|
143 | return obj;
|
144 | };
|
145 |
|
146 | babelHelpers.extends = Object.assign || function (target) {
|
147 | for (var i = 1; i < arguments.length; i++) {
|
148 | var source = arguments[i];
|
149 |
|
150 | for (var key in source) {
|
151 | if (Object.prototype.hasOwnProperty.call(source, key)) {
|
152 | target[key] = source[key];
|
153 | }
|
154 | }
|
155 | }
|
156 |
|
157 | return target;
|
158 | };
|
159 |
|
160 | babelHelpers.get = function get(object, property, receiver) {
|
161 | if (object === null) object = Function.prototype;
|
162 | var desc = Object.getOwnPropertyDescriptor(object, property);
|
163 |
|
164 | if (desc === undefined) {
|
165 | var parent = Object.getPrototypeOf(object);
|
166 |
|
167 | if (parent === null) {
|
168 | return undefined;
|
169 | } else {
|
170 | return get(parent, property, receiver);
|
171 | }
|
172 | } else if ("value" in desc) {
|
173 | return desc.value;
|
174 | } else {
|
175 | var getter = desc.get;
|
176 |
|
177 | if (getter === undefined) {
|
178 | return undefined;
|
179 | }
|
180 |
|
181 | return getter.call(receiver);
|
182 | }
|
183 | };
|
184 |
|
185 | babelHelpers.inherits = function (subClass, superClass) {
|
186 | if (typeof superClass !== "function" && superClass !== null) {
|
187 | throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
188 | }
|
189 |
|
190 | subClass.prototype = Object.create(superClass && superClass.prototype, {
|
191 | constructor: {
|
192 | value: subClass,
|
193 | enumerable: false,
|
194 | writable: true,
|
195 | configurable: true
|
196 | }
|
197 | });
|
198 | if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
199 | };
|
200 |
|
201 | babelHelpers.instanceof = function (left, right) {
|
202 | if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
203 | return right[Symbol.hasInstance](left);
|
204 | } else {
|
205 | return left instanceof right;
|
206 | }
|
207 | };
|
208 |
|
209 | babelHelpers.interopRequireDefault = function (obj) {
|
210 | return obj && obj.__esModule ? obj : {
|
211 | default: obj
|
212 | };
|
213 | };
|
214 |
|
215 | babelHelpers.interopRequireWildcard = function (obj) {
|
216 | if (obj && obj.__esModule) {
|
217 | return obj;
|
218 | } else {
|
219 | var newObj = {};
|
220 |
|
221 | if (obj != null) {
|
222 | for (var key in obj) {
|
223 | if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
|
224 | }
|
225 | }
|
226 |
|
227 | newObj.default = obj;
|
228 | return newObj;
|
229 | }
|
230 | };
|
231 |
|
232 | babelHelpers.newArrowCheck = function (innerThis, boundThis) {
|
233 | if (innerThis !== boundThis) {
|
234 | throw new TypeError("Cannot instantiate an arrow function");
|
235 | }
|
236 | };
|
237 |
|
238 | babelHelpers.objectDestructuringEmpty = function (obj) {
|
239 | if (obj == null) throw new TypeError("Cannot destructure undefined");
|
240 | };
|
241 |
|
242 | babelHelpers.objectWithoutProperties = function (obj, keys) {
|
243 | var target = {};
|
244 |
|
245 | for (var i in obj) {
|
246 | if (keys.indexOf(i) >= 0) continue;
|
247 | if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
|
248 | target[i] = obj[i];
|
249 | }
|
250 |
|
251 | return target;
|
252 | };
|
253 |
|
254 | babelHelpers.possibleConstructorReturn = function (self, call) {
|
255 | if (!self) {
|
256 | throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
257 | }
|
258 |
|
259 | return call && (typeof call === "object" || typeof call === "function") ? call : self;
|
260 | };
|
261 |
|
262 | babelHelpers.selfGlobal = typeof global === "undefined" ? self : global;
|
263 |
|
264 | babelHelpers.set = function set(object, property, value, receiver) {
|
265 | var desc = Object.getOwnPropertyDescriptor(object, property);
|
266 |
|
267 | if (desc === undefined) {
|
268 | var parent = Object.getPrototypeOf(object);
|
269 |
|
270 | if (parent !== null) {
|
271 | set(parent, property, value, receiver);
|
272 | }
|
273 | } else if ("value" in desc && desc.writable) {
|
274 | desc.value = value;
|
275 | } else {
|
276 | var setter = desc.set;
|
277 |
|
278 | if (setter !== undefined) {
|
279 | setter.call(receiver, value);
|
280 | }
|
281 | }
|
282 |
|
283 | return value;
|
284 | };
|
285 |
|
286 | babelHelpers.slicedToArray = function () {
|
287 | function sliceIterator(arr, i) {
|
288 | var _arr = [];
|
289 | var _n = true;
|
290 | var _d = false;
|
291 | var _e = undefined;
|
292 |
|
293 | try {
|
294 | for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
|
295 | _arr.push(_s.value);
|
296 |
|
297 | if (i && _arr.length === i) break;
|
298 | }
|
299 | } catch (err) {
|
300 | _d = true;
|
301 | _e = err;
|
302 | } finally {
|
303 | try {
|
304 | if (!_n && _i["return"]) _i["return"]();
|
305 | } finally {
|
306 | if (_d) throw _e;
|
307 | }
|
308 | }
|
309 |
|
310 | return _arr;
|
311 | }
|
312 |
|
313 | return function (arr, i) {
|
314 | if (Array.isArray(arr)) {
|
315 | return arr;
|
316 | } else if (Symbol.iterator in Object(arr)) {
|
317 | return sliceIterator(arr, i);
|
318 | } else {
|
319 | throw new TypeError("Invalid attempt to destructure non-iterable instance");
|
320 | }
|
321 | };
|
322 | }();
|
323 |
|
324 | babelHelpers.slicedToArrayLoose = function (arr, i) {
|
325 | if (Array.isArray(arr)) {
|
326 | return arr;
|
327 | } else if (Symbol.iterator in Object(arr)) {
|
328 | var _arr = [];
|
329 |
|
330 | for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
|
331 | _arr.push(_step.value);
|
332 |
|
333 | if (i && _arr.length === i) break;
|
334 | }
|
335 |
|
336 | return _arr;
|
337 | } else {
|
338 | throw new TypeError("Invalid attempt to destructure non-iterable instance");
|
339 | }
|
340 | };
|
341 |
|
342 | babelHelpers.taggedTemplateLiteral = function (strings, raw) {
|
343 | return Object.freeze(Object.defineProperties(strings, {
|
344 | raw: {
|
345 | value: Object.freeze(raw)
|
346 | }
|
347 | }));
|
348 | };
|
349 |
|
350 | babelHelpers.taggedTemplateLiteralLoose = function (strings, raw) {
|
351 | strings.raw = raw;
|
352 | return strings;
|
353 | };
|
354 |
|
355 | babelHelpers.temporalRef = function (val, name, undef) {
|
356 | if (val === undef) {
|
357 | throw new ReferenceError(name + " is not defined - temporal dead zone");
|
358 | } else {
|
359 | return val;
|
360 | }
|
361 | };
|
362 |
|
363 | babelHelpers.temporalUndefined = {};
|
364 |
|
365 | babelHelpers.toArray = function (arr) {
|
366 | return Array.isArray(arr) ? arr : Array.from(arr);
|
367 | };
|
368 |
|
369 | babelHelpers.toConsumableArray = function (arr) {
|
370 | if (Array.isArray(arr)) {
|
371 | for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
|
372 |
|
373 | return arr2;
|
374 | } else {
|
375 | return Array.from(arr);
|
376 | }
|
377 | };
|