1(function (global) { 2 var babelHelpers = global.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 && obj !== Symbol.prototype ? "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.asyncIterator = function (iterable) { 53 if (typeof Symbol === "function") { 54 if (Symbol.asyncIterator) { 55 var method = iterable[Symbol.asyncIterator]; 56 if (method != null) return method.call(iterable); 57 } 58 59 if (Symbol.iterator) { 60 return iterable[Symbol.iterator](); 61 } 62 } 63 64 throw new TypeError("Object is not async iterable"); 65 }; 66 67 babelHelpers.asyncGenerator = function () { 68 function AwaitValue(value) { 69 this.value = value; 70 } 71 72 function AsyncGenerator(gen) { 73 var front, back; 74 75 function send(key, arg) { 76 return new Promise(function (resolve, reject) { 77 var request = { 78 key: key, 79 arg: arg, 80 resolve: resolve, 81 reject: reject, 82 next: null 83 }; 84 85 if (back) { 86 back = back.next = request; 87 } else { 88 front = back = request; 89 resume(key, arg); 90 } 91 }); 92 } 93 94 function resume(key, arg) { 95 try { 96 var result = gen[key](arg); 97 var value = result.value; 98 99 if (value instanceof AwaitValue) { 100 Promise.resolve(value.value).then(function (arg) { 101 resume("next", arg); 102 }, function (arg) { 103 resume("throw", arg); 104 }); 105 } else { 106 settle(result.done ? "return" : "normal", result.value); 107 } 108 } catch (err) { 109 settle("throw", err); 110 } 111 } 112 113 function settle(type, value) { 114 switch (type) { 115 case "return": 116 front.resolve({ 117 value: value, 118 done: true 119 }); 120 break; 121 122 case "throw": 123 front.reject(value); 124 break; 125 126 default: 127 front.resolve({ 128 value: value, 129 done: false 130 }); 131 break; 132 } 133 134 front = front.next; 135 136 if (front) { 137 resume(front.key, front.arg); 138 } else { 139 back = null; 140 } 141 } 142 143 this._invoke = send; 144 145 if (typeof gen.return !== "function") { 146 this.return = undefined; 147 } 148 } 149 150 if (typeof Symbol === "function" && Symbol.asyncIterator) { 151 AsyncGenerator.prototype[Symbol.asyncIterator] = function () { 152 return this; 153 }; 154 } 155 156 AsyncGenerator.prototype.next = function (arg) { 157 return this._invoke("next", arg); 158 }; 159 160 AsyncGenerator.prototype.throw = function (arg) { 161 return this._invoke("throw", arg); 162 }; 163 164 AsyncGenerator.prototype.return = function (arg) { 165 return this._invoke("return", arg); 166 }; 167 168 return { 169 wrap: function (fn) { 170 return function () { 171 return new AsyncGenerator(fn.apply(this, arguments)); 172 }; 173 }, 174 await: function (value) { 175 return new AwaitValue(value); 176 } 177 }; 178 }(); 179 180 babelHelpers.asyncGeneratorDelegate = function (inner, awaitWrap) { 181 var iter = {}, 182 waiting = false; 183 184 function pump(key, value) { 185 waiting = true; 186 value = new Promise(function (resolve) { 187 resolve(inner[key](value)); 188 }); 189 return { 190 done: false, 191 value: awaitWrap(value) 192 }; 193 } 194 195 ; 196 197 if (typeof Symbol === "function" && Symbol.iterator) { 198 iter[Symbol.iterator] = function () { 199 return this; 200 }; 201 } 202 203 iter.next = function (value) { 204 if (waiting) { 205 waiting = false; 206 return value; 207 } 208 209 return pump("next", value); 210 }; 211 212 if (typeof inner.throw === "function") { 213 iter.throw = function (value) { 214 if (waiting) { 215 waiting = false; 216 throw value; 217 } 218 219 return pump("throw", value); 220 }; 221 } 222 223 if (typeof inner.return === "function") { 224 iter.return = function (value) { 225 return pump("return", value); 226 }; 227 } 228 229 return iter; 230 }; 231 232 babelHelpers.asyncToGenerator = function (fn) { 233 return function () { 234 var gen = fn.apply(this, arguments); 235 return new Promise(function (resolve, reject) { 236 function step(key, arg) { 237 try { 238 var info = gen[key](arg); 239 var value = info.value; 240 } catch (error) { 241 reject(error); 242 return; 243 } 244 245 if (info.done) { 246 resolve(value); 247 } else { 248 return Promise.resolve(value).then(function (value) { 249 step("next", value); 250 }, function (err) { 251 step("throw", err); 252 }); 253 } 254 } 255 256 return step("next"); 257 }); 258 }; 259 }; 260 261 babelHelpers.classCallCheck = function (instance, Constructor) { 262 if (!(instance instanceof Constructor)) { 263 throw new TypeError("Cannot call a class as a function"); 264 } 265 }; 266 267 babelHelpers.createClass = function () { 268 function defineProperties(target, props) { 269 for (var i = 0; i < props.length; i++) { 270 var descriptor = props[i]; 271 descriptor.enumerable = descriptor.enumerable || false; 272 descriptor.configurable = true; 273 if ("value" in descriptor) descriptor.writable = true; 274 Object.defineProperty(target, descriptor.key, descriptor); 275 } 276 } 277 278 return function (Constructor, protoProps, staticProps) { 279 if (protoProps) defineProperties(Constructor.prototype, protoProps); 280 if (staticProps) defineProperties(Constructor, staticProps); 281 return Constructor; 282 }; 283 }(); 284 285 babelHelpers.defineEnumerableProperties = function (obj, descs) { 286 for (var key in descs) { 287 var desc = descs[key]; 288 desc.configurable = desc.enumerable = true; 289 if ("value" in desc) desc.writable = true; 290 Object.defineProperty(obj, key, desc); 291 } 292 293 return obj;
294 }; 295 296 babelHelpers.defaults = function (obj, defaults) { 297 var keys = Object.getOwnPropertyNames(defaults); 298 299 for (var i = 0; i < keys.length; i++) { 300 var key = keys[i]; 301 var value = Object.getOwnPropertyDescriptor(defaults, key); 302 303 if (value && value.configurable && obj[key] === undefined) { 304 Object.defineProperty(obj, key, value); 305 } 306 } 307 308 return obj; 309 }; 310 311 babelHelpers.defineProperty = function (obj, key, value) { 312 if (key in obj) { 313 Object.defineProperty(obj, key, { 314 value: value, 315 enumerable: true, 316 configurable: true, 317 writable: true 318 }); 319 } else { 320 obj[key] = value; 321 } 322 323 return obj; 324 }; 325 326 babelHelpers.extends = Object.assign || function (target) { 327 for (var i = 1; i < arguments.length; i++) { 328 var source = arguments[i]; 329 330 for (var key in source) { 331 if (Object.prototype.hasOwnProperty.call(source, key)) { 332 target[key] = source[key]; 333 } 334 } 335 } 336 337 return target; 338 }; 339 340 babelHelpers.get = function get(object, property, receiver) { 341 if (object === null) object = Function.prototype; 342 var desc = Object.getOwnPropertyDescriptor(object, property); 343 344 if (desc === undefined) { 345 var parent = Object.getPrototypeOf(object); 346 347 if (parent === null) { 348 return undefined; 349 } else { 350 return get(parent, property, receiver); 351 } 352 } else if ("value" in desc) { 353 return desc.value; 354 } else { 355 var getter = desc.get; 356 357 if (getter === undefined) { 358 return undefined; 359 } 360 361 return getter.call(receiver); 362 } 363 }; 364 365 babelHelpers.inherits = function (subClass, superClass) { 366 if (typeof superClass !== "function" && superClass !== null) { 367 throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); 368 } 369 370 subClass.prototype = Object.create(superClass && superClass.prototype, { 371 constructor: { 372 value: subClass, 373 enumerable: false, 374 writable: true, 375 configurable: true 376 } 377 }); 378 if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; 379 }; 380 381 babelHelpers.instanceof = function (left, right) { 382 if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { 383 return right[Symbol.hasInstance](left); 384 } else { 385 return left instanceof right; 386 } 387 }; 388 389 babelHelpers.interopRequireDefault = function (obj) { 390 return obj && obj.__esModule ? obj : { 391 default: obj 392 }; 393 }; 394 395 babelHelpers.interopRequireWildcard = function (obj) { 396 if (obj && obj.__esModule) { 397 return obj; 398 } else { 399 var newObj = {}; 400 401 if (obj != null) { 402 for (var key in obj) { 403 if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; 404 } 405 } 406 407 newObj.default = obj; 408 return newObj; 409 } 410 }; 411 412 babelHelpers.newArrowCheck = function (innerThis, boundThis) { 413 if (innerThis !== boundThis) { 414 throw new TypeError("Cannot instantiate an arrow function"); 415 } 416 }; 417 418 babelHelpers.objectDestructuringEmpty = function (obj) { 419 if (obj == null) throw new TypeError("Cannot destructure undefined"); 420 }; 421 422 babelHelpers.objectWithoutProperties = function (obj, keys) { 423 var target = {}; 424 425 for (var i in obj) { 426 if (keys.indexOf(i) >= 0) continue; 427 if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; 428 target[i] = obj[i]; 429 } 430 431 return target; 432 }; 433 434 babelHelpers.possibleConstructorReturn = function (self, call) { 435 if (!self) { 436 throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 437 } 438 439 return call && (typeof call === "object" || typeof call === "function") ? call : self; 440 }; 441 442 babelHelpers.selfGlobal = typeof global === "undefined" ? self : global; 443 444 babelHelpers.set = function set(object, property, value, receiver) { 445 var desc = Object.getOwnPropertyDescriptor(object, property); 446 447 if (desc === undefined) { 448 var parent = Object.getPrototypeOf(object); 449 450 if (parent !== null) { 451 set(parent, property, value, receiver); 452 } 453 } else if ("value" in desc && desc.writable) { 454 desc.value = value; 455 } else { 456 var setter = desc.set; 457 458 if (setter !== undefined) { 459 setter.call(receiver, value); 460 } 461 } 462 463 return value; 464 }; 465 466 babelHelpers.slicedToArray = function () { 467 function sliceIterator(arr, i) { 468 var _arr = []; 469 var _n = true; 470 var _d = false; 471 var _e = undefined; 472
473 try { 474 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 475 _arr.push(_s.value); 476 477 if (i && _arr.length === i) break; 478 } 479 } catch (err) { 480 _d = true; 481 _e = err; 482 } finally { 483 try { 484 if (!_n && _i["return"]) _i["return"](); 485 } finally { 486 if (_d) throw _e; 487 } 488 } 489 490 return _arr; 491 } 492 493 return function (arr, i) { 494 if (Array.isArray(arr)) { 495 return arr; 496 } else if (Symbol.iterator in Object(arr)) { 497 return sliceIterator(arr, i); 498 } else { 499 throw new TypeError("Invalid attempt to destructure non-iterable instance"); 500 } 501 }; 502 }(); 503 504 babelHelpers.slicedToArrayLoose = function (arr, i) { 505 if (Array.isArray(arr)) { 506 return arr; 507 } else if (Symbol.iterator in Object(arr)) { 508 var _arr = []; 509 510 for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { 511 _arr.push(_step.value); 512 513 if (i && _arr.length === i) break; 514 } 515 516 return _arr; 517 } else { 518 throw new TypeError("Invalid attempt to destructure non-iterable instance"); 519 } 520 }; 521 522 babelHelpers.taggedTemplateLiteral = function (strings, raw) { 523 return Object.freeze(Object.defineProperties(strings, { 524 raw: { 525 value: Object.freeze(raw) 526 } 527 })); 528 }; 529 530 babelHelpers.taggedTemplateLiteralLoose = function (strings, raw) { 531 strings.raw = raw; 532 return strings; 533 }; 534 535 babelHelpers.temporalRef = function (val, name, undef) { 536 if (val === undef) { 537 throw new ReferenceError(name + " is not defined - temporal dead zone"); 538 } else { 539 return val; 540 } 541 }; 542 543 babelHelpers.temporalUndefined = {}; 544 545 babelHelpers.toArray = function (arr) { 546 return Array.isArray(arr) ? arr : Array.from(arr); 547 }; 548 549 babelHelpers.toConsumableArray = function (arr) { 550 if (Array.isArray(arr)) { 551 for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; 552 553 return arr2; 554 } else { 555 return Array.from(arr); 556 } 557 }; 558})(typeof global === "undefined" ? self : global);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.