1(self["webpackChunkgastro"] = self["webpackChunkgastro"] || []).push([["polyfills"],{ 2 3/***/ 12626: 4/*!*********************************************************************************!*\ 5 !*** ./node_modules/@angular-devkit/build-angular/src/webpack/jit-polyfills.js ***! 6 \*********************************************************************************/ 7/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 8 9"use strict"; 10__webpack_require__.r(__webpack_exports__); 11/* harmony import */ var core_js_proposals_reflect_metadata__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core-js/proposals/reflect-metadata */ 17168); 12/* harmony import */ var core_js_proposals_reflect_metadata__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_proposals_reflect_metadata__WEBPACK_IMPORTED_MODULE_0__); 13/** 14 * @license 15 * Copyright Google LLC All Rights Reserved. 16 * 17 * Use of this source code is governed by an MIT-style license that can be 18 * found in the LICENSE file at https://angular.io/license 19 */ 20 21 22 23 24/***/ }), 25 26/***/ 99140: 27/*!*******************************************!*\ 28 !*** ./node_modules/zone.js/dist/zone.js ***! 29 \*******************************************/ 30/***/ (function(module, exports, __webpack_require__) { 31 32"use strict"; 33var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__; 34var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { 35 if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { 36 if (ar || !(i in from)) { 37 if (!ar) ar = Array.prototype.slice.call(from, 0, i); 38 ar[i] = from[i]; 39 } 40 } 41 return to.concat(ar || Array.prototype.slice.call(from)); 42}; 43/** 44 * @license Angular v14.2.0-next.0 45 * (c) 2010-2022 Google LLC. https://angular.io/ 46 * License: MIT 47 */ 48(function (factory) { 49 true ? !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 50 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 51 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 52 __WEBPACK_AMD_DEFINE_FACTORY__), 53 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : 54 0; 55})((function () { 56 'use strict'; 57 /** 58 * @license 59 * Copyright Google LLC All Rights Reserved. 60 * 61 * Use of this source code is governed by an MIT-style license that can be 62 * found in the LICENSE file at https://angular.io/license 63 */ 64 ((function (global) { 65 var performance = global['performance']; 66 function mark(name) { 67 performance && performance['mark'] && performance['mark'](name); 68 } 69 function performanceMeasure(name, label) { 70 performance && performance['measure'] && performance['measure'](name, label); 71 } 72 mark('Zone'); 73 // Initialize before it's accessed below. 74 // __Zone_symbol_prefix global can be used to override the default zone 75 // symbol prefix with a custom one if needed. 76 var symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__'; 77 function __symbol__(name) { 78 return symbolPrefix + name; 79 } 80 var checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true; 81 if (global['Zone']) { 82 // if global['Zone'] already exists (maybe zone.js was already loaded or 83 // some other lib also registered a global object named Zone), we may need 84 // to throw an error, but sometimes user may not want this error. 85 // For example, 86 // we have two web pages, page1 includes zone.js, page2 doesn't. 87 // and the 1st time user load page1 and page2, everything work fine, 88 // but when user load page2 again, error occurs because global['Zone'] already exists. 89 // so we add a flag to let user choose whether to throw this error or not. 90 // By default, if existing Zone is from zone.js, we will not throw the error. 91 if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') { 92 throw new Error('Zone already loaded.'); 93 } 94 else { 95 return global['Zone']; 96 } 97 } 98 var Zone = /** @class */ (function () { 99 function Zone(parent, zoneSpec) { 100 this._parent = parent; 101 this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>'; 102 this._properties = zoneSpec && zoneSpec.properties || {}; 103 this._zoneDelegate = 104 new _ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec); 105 } 106 Zone.assertZonePatched = function () { 107 if (global['Promise'] !== patches['ZoneAwarePromise']) { 108 throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' + 109 'has been overwritten.\n' + 110 'Most likely cause is that a Promise polyfill has been loaded ' + 111 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' + 112 'If you must load one, do so before loading zone.js.)'); 113 } 114 }; 115 Object.defineProperty(Zone, "root", { 116 get: function () { 117 var zone = Zone.current; 118 while (zone.parent) { 119 zone = zone.parent; 120 } 121 return zone; 122 }, 123 enumerable: false, 124 configurable: true 125 }); 126 Object.defineProperty(Zone, "current", { 127 get: function () { 128 return _currentZoneFrame.zone; 129 }, 130 enumerable: false, 131 configurable: true 132 }); 133 Object.defineProperty(Zone, "currentTask", { 134 get: function () { 135 return _currentTask; 136 }, 137 enumerable: false, 138 configurable: true 139 }); 140 // tslint:disable-next-line:require-internal-with-underscore 141 Zone.__load_patch = function (name, fn, ignoreDuplicate) { 142 if (ignoreDuplicate === void 0) { ignoreDuplicate = false; } 143 if (patches.hasOwnProperty(name)) { 144 // `checkDuplicate` option is defined from global variable 145 // so it works for all modules. 146 // `ignoreDuplicate` can work for the specified module 147 if (!ignoreDuplicate && checkDuplicate) { 148 throw Error('Already loaded patch: ' + n
148ame); 149 } 150 } 151 else if (!global['__Zone_disable_' + name]) { 152 var perfName = 'Zone:' + name; 153 mark(perfName); 154 patches[name] = fn(global, Zone, _api); 155 performanceMeasure(perfName, perfName); 156 } 157 }; 158 Object.defineProperty(Zone.prototype, "parent", { 159 get: function () { 160 return this._parent; 161 }, 162 enumerable: false, 163 configurable: true 164 }); 165 Object.defineProperty(Zone.prototype, "name", { 166 get: function () { 167 return this._name; 168 }, 169 enumerable: false, 170 configurable: true 171 }); 172 Zone.prototype.get = function (key) { 173 var zone = this.getZoneWith(key); 174 if (zone) 175 return zone._properties[key]; 176 }; 177 Zone.prototype.getZoneWith = function (key) { 178 var current = this; 179 while (current) { 180 if (current._properties.hasOwnProperty(key)) { 181 return current; 182 } 183 current = current._parent; 184 } 185 return null; 186 }; 187 Zone.prototype.fork = function (zoneSpec) { 188 if (!zoneSpec) 189 throw new Error('ZoneSpec required!'); 190 return this._zoneDelegate.fork(this, zoneSpec); 191 }; 192 Zone.prototype.wrap = function (callback, source) { 193 if (typeof callback !== 'function') { 194 throw new Error('Expecting function got: ' + callback); 195 } 196 var _callback = this._zoneDelegate.intercept(this, callback, source); 197 var zone = this; 198 return function () { 199 return zone.runGuarded(_callback, this, arguments, source); 200 }; 201 }; 202 Zone.prototype.run = function (callback, applyThis, applyArgs, source) { 203 _currentZoneFrame = { parent: _currentZoneFrame, zone: this }; 204 try { 205 return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); 206 } 207 finally { 208 _currentZoneFrame = _currentZoneFrame.parent; 209 } 210 }; 211 Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) { 212 if (applyThis === void 0) { applyThis = null; } 213 _currentZoneFrame = { parent: _currentZoneFrame, zone: this }; 214 try { 215 try { 216 return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); 217 } 218 catch (error) { 219 if (this._zoneDelegate.handleError(this, error)) { 220 throw error; 221 } 222 } 223 } 224 finally { 225 _currentZoneFrame = _currentZoneFrame.parent; 226 } 227 }; 228 Zone.prototype.runTask = function (task, applyThis, applyArgs) { 229 if (task.zone != this) { 230 throw new Error('A task can only be run in the zone of creation! (Creation: ' + 231 (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')'); 232 } 233 // https://github.com/angular/zone.js/issues/778, sometimes eventTask 234 // will run in notScheduled(canceled) state, we should not try to 235 // run such kind of task but just return 236 if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) { 237 return; 238 } 239 var reEntryGuard = task.state != running; 240 reEntryGuard && task._transitionTo(running, scheduled); 241 task.runCount++; 242 var previousTask = _currentTask; 243 _currentTask = task; 244 _currentZoneFrame = { parent: _currentZoneFrame, zone: this }; 245 try { 246 if (task.type == macroTask && task.data && !task.data.isPeriodic) { 247 task.cancelFn = undefined; 248 } 249 try { 250 return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs); 251 } 252 catch (error) { 253 if (this._zoneDelegate.handleError(this, error)) { 254 throw error; 255 } 256 } 257 } 258 finally { 259 // if the task's state is notScheduled or unknown, then it has already been cancelled 260 // we should not reset the state to scheduled 261 if (task.state !== notScheduled && task.state !== unknown) { 262 if (task.type == eventTask || (task.data && task.data.isPeriodic)) { 263 reEntryGuard && task._transitionTo(scheduled, running); 264 } 265 else { 266 task.runCount = 0; 267 this._updateTaskCount(task, -1); 268 reEntryGuard && 269 task._transitionTo(notScheduled, running, notScheduled); 270 } 271 } 272 _currentZoneFrame = _currentZoneFrame.parent; 273 _currentTask = previousTask; 274 } 275 }; 276 Zone.prototype.scheduleTask = function (task) { 277 if (task.zone && task.zone !== this) { 278 // check if the task was rescheduled, the newZone 279 // should not be the children of the original zone 280 var newZone = this; 281 while (newZone) { 282 if (newZone === task.zone) { 283 throw Error("can not reschedule task to ".concat(this.name, " which is descendants of the original zone ").concat(task.zone.name)); 284 } 285 newZone = newZone.parent; 286 } 287 } 288 task._transitionTo(scheduling, notScheduled); 289 var zoneDelegates = []; 290 task._zoneDelegates = zoneDelegates; 291 task._zone = this; 292 try { 293 task = this._zoneDelegate.scheduleTask(this, task); 294 } 295 catch (err) { 296 // should set task's state to unknown when scheduleTask throw error 297 // because the err may from reschedule, so the fromState maybe notScheduled 298 task._transitionTo(unknown, scheduling, notScheduled); 299 // TODO: @JiaLiPassion, should we check the result from handleError? 300 this._zoneDelegate.handleError(this, err); 301 throw err; 302 } 303 if (task._zoneDelegates === zoneDelegates) { 304 // we have to check because internally the delegate can reschedule the task. 305 this._updateTaskCount(task, 1); 306 } 307 if (task.state == scheduling) { 308 task._transitionTo(scheduled, scheduling); 309 } 310 return task; 311 }; 312 Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) { 313 return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined)); 314 }; 315 Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) { 316 return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel)); 317 }; 318 Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) { 319 return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel)); 320 }; 321 Zone.prototype.cancelTask = function (task) { 322 if (task.zone != this) 323 throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' + 324 (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')'); 325 task._transitionTo(canceling, scheduled, running); 326 try { 327 this._zoneDelegate.cancelTask(this, task); 328 } 329 catch (err) { 330 // if error occurs when cancelTask, transit the state to unknown 331 task._transitionTo(unknown, canceling); 332 this._zoneDelegate.handleError(this, err); 333 throw err; 334 } 335 this._updateTaskCount(task, -1); 336 task._transitionTo(notScheduled, canceling); 337 task.runCount = 0; 338 return task; 339 }; 340 Zone.prototype._updateTaskCount = function (task, count) { 341 var zoneDelegates = task._zoneDelegates; 342 if (count == -1) { 343 task._zoneDelegates = null; 344 } 345 for (var i = 0; i < zoneDelegates.length; i++) { 346 zoneDelegates[i]._updateTaskCount(task.type, count); 347 } 348 }; 349 return Zone; 350 }()); 351 // tslint:disable-next-line:require-internal-with-underscore 352 Zone.__symbol__ = __symbol__; 353 var DELEGATE_ZS = { 354 name: '', 355 onHasTask: function (delegate, _, target, hasTaskState) { return delegate.hasTask(target, hasTaskState); }, 356 onScheduleTask: function (delegate, _, target, task) { return delegate.scheduleTask(target, task); }, 357 onInvokeTask: function (delegate, _, target, task, applyThis, applyArgs) { return delegate.invokeTask(target, task, applyThis, applyArgs); }, 358 onCancelTask: function (delegate, _, target, task) { return delegate.cancelTask(target, task); } 359 }; 360 var _ZoneDelegate = /** @class */ (function () { 361 function _ZoneDelegate(zone, parentDelegate, zoneSpec) { 362 this._taskCounts = { 'microTask': 0, 'macroTask': 0, 'eventTask': 0 }; 363 this.zone = zone; 364 this._parentDelegate = parentDelegate; 365 this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS); 366 this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt); 367 this._forkCurrZone = 368 zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate._forkCurrZone); 369 this._interceptZS = 370 zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS); 371 this._interceptDlgt = 372 zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt); 373 this._interceptCurrZone = 374 zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate._interceptCurrZone); 375 this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS); 376 this._invokeDlgt = 377 zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt); 378 this._invokeCurrZone = 379 zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate._invokeCurrZone); 380 this._handleErrorZS = 381 zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS); 382 this._handleErrorDlgt = 383 zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt); 384 this._handleErrorCurrZone = 385 zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate._handleErrorCurrZone); 386 this._scheduleTaskZS = 387 zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS); 388 this._scheduleTaskDlgt = zoneSpec && 389 (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt); 390 this._scheduleTaskCurrZone = 391 zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate._scheduleTaskCurrZone); 392 this._invokeTaskZS = 393 zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS); 394 this._invokeTaskDlgt = 395 zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt); 396 this._invokeTaskCurrZone = 397 zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate._invokeTaskCurrZone); 398 this._cancelTaskZS = 399 zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS); 400 this._cancelTaskDlgt = 401 zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt); 402 this._cancelTaskCurrZone = 403 zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate._cancelTaskCurrZone); 404 this._hasTaskZS = null; 405 this._hasTaskDlgt = null; 406 this._hasTaskDlgtOwner = null; 407 this._hasTaskCurrZone = null; 408 var zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask; 409 var parentHasTask = parentDelegate && parentDelegate._hasTaskZS; 410 if (zoneSpecHasTask || parentHasTask) { 411 // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such 412 // a case all task related interceptors must go through this ZD. We can't short circuit it. 413 this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS; 414 this._hasTaskDlgt = parentDelegate; 415 this._hasTaskDlgtOwner = this; 416 this._hasTaskCurrZone = zone; 417 if (!zoneSpec.onScheduleTask) { 418 this._scheduleTaskZS = DELEGATE_ZS; 419 this._scheduleTaskDlgt = parentDelegate; 420 this._scheduleTaskCurrZone = this.zone; 421 } 422 if (!zoneSpec.onInvokeTask) { 423 this._invokeTaskZS = DELEGATE_ZS; 424 this._invokeTaskDlgt = parentDelegate; 425 this._invokeTaskCurrZone = this.zone; 426 } 427 if (!zoneSpec.onCancelTask) { 428 this._cancelTaskZS = DELEGATE_ZS; 429 this._cancelTaskDlgt = parentDelegate; 430 this._cancelTaskCurrZone = this.zone; 431 } 432 } 433 } 434 _ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) { 435 return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) : 436 new Zone(targetZone, zoneSpec); 437 }; 438 _ZoneDelegate.prototype.intercept = function (targetZone, callback, source) { 439 return this._interceptZS ? 440 this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) : 441 callback; 442 }; 443 _ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) { 444 return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) : 445 callback.apply(applyThis, applyArgs); 446 }; 447 _ZoneDelegate.prototype.handleError = function (targetZone, error) { 448 return this._handleErrorZS ? 449 this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._h
vendor: 6,077 bytes, lines 449-587
449andleErrorCurrZone, targetZone, error) : 450 true; 451 }; 452 _ZoneDelegate.prototype.scheduleTask = function (targetZone, task) { 453 var returnTask = task; 454 if (this._scheduleTaskZS) { 455 if (this._hasTaskZS) { 456 returnTask._zoneDelegates.push(this._hasTaskDlgtOwner); 457 } 458 // clang-format off 459 returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task); 460 // clang-format on 461 if (!returnTask) 462 returnTask = task; 463 } 464 else { 465 if (task.scheduleFn) { 466 task.scheduleFn(task); 467 } 468 else if (task.type == microTask) { 469 scheduleMicroTask(task); 470 } 471 else { 472 throw new Error('Task is missing scheduleFn.'); 473 } 474 } 475 return returnTask; 476 }; 477 _ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) { 478 return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) : 479 task.callback.apply(applyThis, applyArgs); 480 }; 481 _ZoneDelegate.prototype.cancelTask = function (targetZone, task) { 482 var value; 483 if (this._cancelTaskZS) { 484 value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task); 485 } 486 else { 487 if (!task.cancelFn) { 488 throw Error('Task is not cancelable'); 489 } 490 value = task.cancelFn(task); 491 } 492 return value; 493 }; 494 _ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) { 495 // hasTask should not throw error so other ZoneDelegate 496 // can still trigger hasTask callback 497 try { 498 this._hasTaskZS && 499 this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty); 500 } 501 catch (err) { 502 this.handleError(targetZone, err); 503 } 504 }; 505 // tslint:disable-next-line:require-internal-with-underscore 506 _ZoneDelegate.prototype._updateTaskCount = function (type, count) { 507 var counts = this._taskCounts; 508 var prev = counts[type]; 509 var next = counts[type] = prev + count; 510 if (next < 0) { 511 throw new Error('More tasks executed then were scheduled.'); 512 } 513 if (prev == 0 || next == 0) { 514 var isEmpty = { 515 microTask: counts['microTask'] > 0, 516 macroTask: counts['macroTask'] > 0, 517 eventTask: counts['eventTask'] > 0, 518 change: type 519 }; 520 this.hasTask(this.zone, isEmpty); 521 } 522 }; 523 return _ZoneDelegate; 524 }()); 525 var ZoneTask = /** @class */ (function () { 526 function ZoneTask(type, source, callback, options, scheduleFn, cancelFn) { 527 // tslint:disable-next-line:require-internal-with-underscore 528 this._zone = null; 529 this.runCount = 0; 530 // tslint:disable-next-line:require-internal-with-underscore 531 this._zoneDelegates = null; 532 // tslint:disable-next-line:require-internal-with-underscore 533 this._state = 'notScheduled'; 534 this.type = type; 535 this.source = source; 536 this.data = options; 537 this.scheduleFn = scheduleFn; 538 this.cancelFn = cancelFn; 539 if (!callback) { 540 throw new Error('callback is not defined'); 541 } 542 this.callback = callback; 543 var self = this; 544 // TODO: @JiaLiPassion options should have interface 545 if (type === eventTask && options && options.useG) { 546 this.invoke = ZoneTask.invokeTask; 547 } 548 else { 549 this.invoke = function () { 550 return ZoneTask.invokeTask.call(global, self, this, arguments); 551 }; 552 } 553 } 554 ZoneTask.invokeTask = function (task, target, args) { 555 if (!task) { 556 task = this; 557 } 558 _numberOfNestedTaskFrames++; 559 try { 560 task.runCount++; 561 return task.zone.runTask(task, target, args); 562 } 563 finally { 564 if (_numberOfNestedTaskFrames == 1) { 565 drainMicroTaskQueue(); 566 } 567 _numberOfNestedTaskFrames--; 568 } 569 }; 570 Object.defineProperty(ZoneTask.prototype, "zone", { 571 get: function () { 572 return this._zone; 573 }, 574 enumerable: false, 575 configurable: true 576 }); 577 Object.defineProperty(ZoneTask.prototype, "state", { 578 get: function () { 579 return this._state; 580 }, 581 enumerable: false, 582 configurable: true 583 }); 584 ZoneTask.prototype.cancelScheduleRequest = function () { 585 this._transitionTo(notScheduled, scheduling); 586 }; 587 // tslint:disable-next-line:require-internal-with-underscore
588 ZoneTask.prototype._transitionTo = function (toState, fromState1, fromState2) { 589 if (this._state === fromState1 || this._state === fromState2) { 590 this._state = toState; 591 if (toState == notScheduled) { 592 this._zoneDelegates = null; 593 } 594 } 595 else { 596 throw new Error("".concat(this.type, " '").concat(this.source, "': can not transition to '").concat(toState, "', expecting state '").concat(fromState1, "'").concat(fromState2 ? ' or \'' + fromState2 + '\'' : '', ", was '").concat(this._state, "'.")); 597 } 598 }; 599 ZoneTask.prototype.toString = function () { 600 if (this.data && typeof this.data.handleId !== 'undefined') { 601 return this.data.handleId.toString(); 602 } 603 else { 604 return Object.prototype.toString.call(this); 605 } 606 }; 607 // add toJSON method to prevent cyclic error when 608 // call JSON.stringify(zoneTask) 609 ZoneTask.prototype.toJSON = function () { 610 return { 611 type: this.type, 612 state: this.state, 613 source: this.source, 614 zone: this.zone.name, 615 runCount: this.runCount 616 }; 617 }; 618 return ZoneTask; 619 }());
vendor: 2,677 bytes, lines 620-678
620 ////////////////////////////////////////////////////// 621 ////////////////////////////////////////////////////// 622 /// MICROTASK QUEUE 623 ////////////////////////////////////////////////////// 624 ////////////////////////////////////////////////////// 625 var symbolSetTimeout = __symbol__('setTimeout'); 626 var symbolPromise = __symbol__('Promise'); 627 var symbolThen = __symbol__('then'); 628 var _microTaskQueue = []; 629 var _isDrainingMicrotaskQueue = false; 630 var nativeMicroTaskQueuePromise; 631 function nativeScheduleMicroTask(func) { 632 if (!nativeMicroTaskQueuePromise) { 633 if (global[symbolPromise]) { 634 nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0); 635 } 636 } 637 if (nativeMicroTaskQueuePromise) { 638 var nativeThen = nativeMicroTaskQueuePromise[symbolThen]; 639 if (!nativeThen) { 640 // native Promise is not patchable, we need to use `then` directly 641 // issue 1078 642 nativeThen = nativeMicroTaskQueuePromise['then']; 643 } 644 nativeThen.call(nativeMicroTaskQueuePromise, func); 645 } 646 else { 647 global[symbolSetTimeout](func, 0); 648 } 649 } 650 function scheduleMicroTask(task) { 651 // if we are not running in any task, and there has not been anything scheduled 652 // we must bootstrap the initial task creation by manually scheduling the drain 653 if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) { 654 // We are not running in Task, so we need to kickstart the microtask queue. 655 nativeScheduleMicroTask(drainMicroTaskQueue); 656 } 657 task && _microTaskQueue.push(task); 658 } 659 function drainMicroTaskQueue() { 660 if (!_isDrainingMicrotaskQueue) { 661 _isDrainingMicrotaskQueue = true; 662 while (_microTaskQueue.length) { 663 var queue = _microTaskQueue; 664 _microTaskQueue = []; 665 for (var i = 0; i < queue.length; i++) { 666 var task = queue[i]; 667 try { 668 task.zone.runTask(task, null, null); 669 } 670 catch (error) { 671 _api.onUnhandledError(error); 672 } 673 } 674 } 675 _api.microtaskDrainDone(); 676 _isDrainingMicrotaskQueue = false; 677 } 678 }
679 ////////////////////////////////////////////////////// 680 ////////////////////////////////////////////////////// 681 /// BOOTSTRAP 682 ////////////////////////////////////////////////////// 683 ////////////////////////////////////////////////////// 684 var NO_ZONE = { name: 'NO ZONE' }; 685 var notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown'; 686 var microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask'; 687 var patches = {}; 688 var _api = { 689 symbol: __symbol__, 690 currentZoneFrame: function () { return _currentZoneFrame; }, 691 onUnhandledError: noop, 692 microtaskDrainDone: noop, 693 scheduleMicroTask: scheduleMicroTask, 694 showUncaughtError: function () { return !Zone[__symbol__('ignoreConsoleErrorUncaughtError')]; }, 695 patchEventTarget: function () { return []; }, 696 patchOnProperties: noop, 697 patchMethod: function () { return noop; }, 698 bindArguments: function () { return []; }, 699 patchThen: function () { return noop; }, 700 patchMacroTask: function () { return noop; }, 701 patchEventPrototype: function () { return noop; }, 702 isIEOrEdge: function () { return false; }, 703 getGlobalObjects: function () { return undefined; }, 704 ObjectDefineProperty: function () { return noop; }, 705 ObjectGetOwnPropertyDescriptor: function () { return undefined; }, 706 ObjectCreate: function () { return undefined; }, 707 ArraySlice: function () { return []; }, 708 patchClass: function () { return noop; }, 709 wrapWithCurrentZone: function () { return noop; }, 710 filterProperties: function () { return []; }, 711 attachOriginToPatched: function () { return noop; }, 712 _redefineProperty: function () { return noop; }, 713 patchCallbacks: function () { return noop; }, 714 nativeScheduleMicroTask: nativeScheduleMicroTask 715 }; 716 var _currentZoneFrame = { parent: null, zone: new Zone(null, null) }; 717 var _currentTask = null; 718 var _numberOfNestedTaskFrames = 0; 719 function noop() { } 720 performanceMeasure('Zone', 'Zone'); 721 return global['Zone'] = Zone; 722 }))(typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global); 723 /** 724 * @license 725 * Copyright Google LLC All Rights Reserved. 726 * 727 * Use of this source code is governed by an MIT-style license that can be 728 * found in the LICENSE file at https://angular.io/license 729 */ 730 /** 731 * Suppress closure compiler errors about unknown 'Zone' variable 732 * @fileoverview 733 * @suppress {undefinedVars,globalThis,missingRequire} 734 */ 735 /// <reference types="node"/> 736 // issue #989, to reduce bundle size, use short name 737 /** Object.getOwnPropertyDescriptor */ 738 var ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 739 /** Object.defineProperty */ 740 var ObjectDefineProperty = Object.defineProperty; 741 /** Object.getPrototypeOf */ 742 var ObjectGetPrototypeOf = Object.getPrototypeOf; 743 /** Object.create */ 744 var ObjectCreate = Object.create; 745 /** Array.prototype.slice */ 746 var ArraySlice = Array.prototype.slice; 747 /** addEventListener string const */ 748 var ADD_EVENT_LISTENER_STR = 'addEventListener'; 749 /** removeEventListener string const */ 750 var REMOVE_EVENT_LISTENER_STR = 'removeEventListener'; 751 /** zoneSymbol addEventListener */ 752 var ZONE_SYMBOL_ADD_EVENT_LISTENER = Zone.__symbol__(ADD_EVENT_LISTENER_STR); 753 /** zoneSymbol removeEventListener */
754 var ZONE_SYMBOL_REMOVE_EVENT_LISTENER = Zone.__symbol__(REMOVE_EVENT_LISTENER_STR); 755 /** true string const */ 756 var TRUE_STR = 'true'; 757 /** false string const */ 758 var FALSE_STR = 'false'; 759 /** Zone symbol prefix string const. */ 760 var ZONE_SYMBOL_PREFIX = Zone.__symbol__(''); 761 function wrapWithCurrentZone(callback, source) { 762 return Zone.current.wrap(callback, source); 763 } 764 function scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule, customCancel) { 765 return Zone.current.scheduleMacroTask(source, callback, data, customSchedule, customCancel); 766 } 767 var zoneSymbol$1 = Zone.__symbol__; 768 var isWindowExists = typeof window !== 'undefined'; 769 var internalWindow = isWindowExists ? window : undefined; 770 var _global = isWindowExists && internalWindow || typeof self === 'object' && self || global; 771 var REMOVE_ATTRIBUTE = 'removeAttribute'; 772 function bindArguments(args, source) { 773 for (var i = args.length - 1; i >= 0; i--) { 774 if (typeof args[i] === 'function') { 775 args[i] = wrapWithCurrentZone(args[i], source + '_' + i); 776 } 777 } 778 return args; 779 } 780 function patchPrototype(prototype, fnNames) { 781 var source = prototype.constructor['name']; 782 var _loop_1 = function (i) { 783 var name_1 = fnNames[i]; 784 var delegate = prototype[name_1]; 785 if (delegate) { 786 var prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, name_1); 787 if (!isPropertyWritable(prototypeDesc)) { 788 return "continue"; 789 } 790 prototype[name_1] = (function (delegate) { 791 var patched = function () { 792 return delegate.apply(this, bindArguments(arguments, source + '.' + name_1)); 793 }; 794 attachOriginToPatched(patched, delegate); 795 return patched; 796 })(delegate); 797 } 798 }; 799 for (var i = 0; i < fnNames.length; i++) { 800 _loop_1(i); 801 } 802 } 803 function isPropertyWritable(propertyDesc) { 804 if (!propertyDesc) { 805 return true; 806 } 807 if (propertyDesc.writable === false) { 808 return false; 809 } 810 return !(typeof propertyDesc.get === 'function' && typeof propertyDesc.set === 'undefined'); 811 } 812 var isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope); 813 // Make sure to access `process` through `_global` so that WebPack does not accidentally browserify 814 // this code. 815 var isNode = (!('nw' in _global) && typeof _global.process !== 'undefined' && 816 {}.toString.call(_global.process) === '[object process]'); 817 var isBrowser = !isNode && !isWebWorker && !!(isWindowExists && internalWindow['HTMLElement']); 818 // we are in electron of nw, so we are both browser and nodejs 819 // Make sure to access `process` through `_global` so that WebPack does not accidentally browserify 820 // this code. 821 var isMix = typeof _global.process !== 'undefined' && 822 {}.toString.call(_global.process) === '[object process]' && !isWebWorker && 823 !!(isWindowExists && internalWindow['HTMLElement']); 824 var zoneSymbolEventNames$1 = {}; 825 var wrapFn = function (event) { 826 // https://github.com/angular/zone.js/issues/911, in IE, sometimes 827 // event will be undefined, so we need to use window.event 828 event = event || _global.event; 829 if (!event) { 830 return; 831 } 832 var eventNameSymbol = zoneSymbolEventNames$1[event.type]; 833 if (!eventNameSymbol) { 834 eventNameSymbol = zoneSymbolEventNames$1[event.type] = zoneSymbol$1('ON_PROPERTY' + event.type); 835 } 836 var target = this || event.target || _global; 837 var listener = target[eventNameSymbol]; 838 var result; 839 if (isBrowser && target === internalWindow && event.type === 'error') { 840 // window.onerror have different signature 841 // https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror#window.onerror 842 // and onerror callback will prevent default when callback return true 843 var errorEvent = event; 844 result = listener && 845 listener.call(this, errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error); 846 if (result === true) { 847 event.preventDefault(); 848 } 849 } 850 else { 851 result = listener && listener.apply(this, arguments); 852 if (result != undefined && !result) { 853 event.preventDefault(); 854 } 855 } 856 return result; 857 }; 858 function patchProperty(obj, prop, prototype) { 859 var desc = ObjectGetOwnPropertyDescriptor(obj, prop); 860 if (!desc && prototype) { 861 // when patch window object, use prototype to check prop exist or not
vendor: 9,127 bytes, lines 862-1072
862 var prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop); 863 if (prototypeDesc) { 864 desc = { enumerable: true, configurable: true }; 865 } 866 } 867 // if the descriptor not exists or is not configurable 868 // just return 869 if (!desc || !desc.configurable) { 870 return; 871 } 872 var onPropPatchedSymbol = zoneSymbol$1('on' + prop + 'patched'); 873 if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) { 874 return; 875 } 876 // A property descriptor cannot have getter/setter and be writable 877 // deleting the writable and value properties avoids this error: 878 // 879 // TypeError: property descriptors must not specify a value or be writable when a 880 // getter or setter has been specified 881 delete desc.writable; 882 delete desc.value; 883 var originalDescGet = desc.get; 884 var originalDescSet = desc.set; 885 // slice(2) cuz 'onclick' -> 'click', etc 886 var eventName = prop.slice(2); 887 var eventNameSymbol = zoneSymbolEventNames$1[eventName]; 888 if (!eventNameSymbol) { 889 eventNameSymbol = zoneSymbolEventNames$1[eventName] = zoneSymbol$1('ON_PROPERTY' + eventName); 890 } 891 desc.set = function (newValue) { 892 // in some of windows's onproperty callback, this is undefined 893 // so we need to check it 894 var target = this; 895 if (!target && obj === _global) { 896 target = _global; 897 } 898 if (!target) { 899 return; 900 } 901 var previousValue = target[eventNameSymbol]; 902 if (typeof previousValue === 'function') { 903 target.removeEventListener(eventName, wrapFn); 904 } 905 // issue #978, when onload handler was added before loading zone.js 906 // we should remove it with originalDescSet 907 originalDescSet && originalDescSet.call(target, null); 908 target[eventNameSymbol] = newValue; 909 if (typeof newValue === 'function') { 910 target.addEventListener(eventName, wrapFn, false); 911 } 912 }; 913 // The getter would return undefined for unassigned properties but the default value of an 914 // unassigned property is null 915 desc.get = function () { 916 // in some of windows's onproperty callback, this is undefined 917 // so we need to check it 918 var target = this; 919 if (!target && obj === _global) { 920 target = _global; 921 } 922 if (!target) { 923 return null; 924 } 925 var listener = target[eventNameSymbol]; 926 if (listener) { 927 return listener; 928 } 929 else if (originalDescGet) { 930 // result will be null when use inline event attribute, 931 // such as <button onclick="func();">OK</button> 932 // because the onclick function is internal raw uncompiled handler 933 // the onclick will be evaluated when first time event was triggered or 934 // the property is accessed, https://github.com/angular/zone.js/issues/525 935 // so we should use original native get to retrieve the handler 936 var value = originalDescGet.call(this); 937 if (value) { 938 desc.set.call(this, value); 939 if (typeof target[REMOVE_ATTRIBUTE] === 'function') { 940 target.removeAttribute(prop); 941 } 942 return value; 943 } 944 } 945 return null; 946 }; 947 ObjectDefineProperty(obj, prop, desc); 948 obj[onPropPatchedSymbol] = true; 949 } 950 function patchOnProperties(obj, properties, prototype) { 951 if (properties) { 952 for (var i = 0; i < properties.length; i++) { 953 patchProperty(obj, 'on' + properties[i], prototype); 954 } 955 } 956 else { 957 var onProperties = []; 958 for (var prop in obj) { 959 if (prop.slice(0, 2) == 'on') { 960 onProperties.push(prop); 961 } 962 } 963 for (var j = 0; j < onProperties.length; j++) { 964 patchProperty(obj, onProperties[j], prototype); 965 } 966 } 967 } 968 var originalInstanceKey = zoneSymbol$1('originalInstance'); 969 // wrap some native API on `window` 970 function patchClass(className) { 971 var OriginalClass = _global[className]; 972 if (!OriginalClass) 973 return; 974 // keep original class in global 975 _global[zoneSymbol$1(className)] = OriginalClass; 976 _global[className] = function () { 977 var a = bindArguments(arguments, className); 978 switch (a.length) { 979 case 0: 980 this[originalInstanceKey] = new OriginalClass(); 981 break; 982 case 1: 983 this[originalInstanceKey] = new OriginalClass(a[0]); 984 break; 985 case 2: 986 this[originalInstanceKey] = new OriginalClass(a[0], a[1]); 987 break; 988 case 3: 989 this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]); 990 break; 991 case 4: 992 this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]); 993 break; 994 default: 995 throw new Error('Arg list too long.'); 996 } 997 }; 998 // attach original delegate to patched function 999 attachOriginToPatched(_global[className], OriginalClass); 1000 var instance = new OriginalClass(function () { }); 1001 var prop; 1002 for (prop in instance) { 1003 // https://bugs.webkit.org/show_bug.cgi?id=44721 1004 if (className === 'XMLHttpRequest' && prop === 'responseBlob') 1005 continue; 1006 (function (prop) { 1007 if (typeof instance[prop] === 'function') { 1008 _global[className].prototype[prop] = function () { 1009 return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments); 1010 }; 1011 } 1012 else { 1013 ObjectDefineProperty(_global[className].prototype, prop, { 1014 set: function (fn) { 1015 if (typeof fn === 'function') { 1016 this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop); 1017 // keep callback in wrapped function so we can 1018 // use it in Function.prototype.toString to return 1019 // the native one. 1020 attachOriginToPatched(this[originalInstanceKey][prop], fn); 1021 } 1022 else { 1023 this[originalInstanceKey][prop] = fn; 1024 } 1025 }, 1026 get: function () { 1027 return this[originalInstanceKey][prop]; 1028 } 1029 }); 1030 } 1031 }(prop)); 1032 } 1033 for (prop in OriginalClass) { 1034 if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) { 1035 _global[className][prop] = OriginalClass[prop]; 1036 } 1037 } 1038 } 1039 function patchMethod(target, name, patchFn) { 1040 var proto = target; 1041 while (proto && !proto.hasOwnProperty(name)) { 1042 proto = ObjectGetPrototypeOf(proto); 1043 } 1044 if (!proto && target[name]) { 1045 // somehow we did not find it, but we can see it. This happens on IE for Window properties. 1046 proto = target; 1047 } 1048 var delegateName = zoneSymbol$1(name); 1049 var delegate = null; 1050 if (proto && (!(delegate = proto[delegateName]) || !proto.hasOwnProperty(delegateName))) { 1051 delegate = proto[delegateName] = proto[name]; 1052 // check whether proto[name] is writable 1053 // some property is readonly in safari, such as HtmlCanvasElement.prototype.toBlob 1054 var desc = proto && ObjectGetOwnPropertyDescriptor(proto, name); 1055 if (isPropertyWritable(desc)) { 1056 var patchDelegate_1 = patchFn(delegate, delegateName, name); 1057 proto[name] = function () { 1058 return patchDelegate_1(this, arguments); 1059 }; 1060 attachOriginToPatched(proto[name], delegate); 1061 } 1062 } 1063 return delegate; 1064 } 1065 // TODO: @JiaLiPassion, support cancel task later if necessary 1066 function patchMacroTask(obj, funcName, metaCreator) { 1067 var setNative = null; 1068 function scheduleTask(task) { 1069 var data = task.data; 1070 data.args[data.cbIdx] = function () { 1071 task.invoke.apply(this, arguments); 1072 };
1073 setNative.apply(data.target, data.args); 1074 return task; 1075 } 1076 setNative = patchMethod(obj, funcName, function (delegate) { return function (self, args) { 1077 var meta = metaCreator(self, args); 1078 if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') { 1079 return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask); 1080 } 1081 else { 1082 // cause an error by calling it directly. 1083 return delegate.apply(self, args); 1084 } 1085 }; }); 1086 } 1087 function attachOriginToPatched(patched, original) { 1088 patched[zoneSymbol$1('OriginalDelegate')] = original; 1089 } 1090 var isDetectedIEOrEdge = false; 1091 var ieOrEdge = false; 1092 function isIE() { 1093 try { 1094 var ua = internalWindow.navigator.userAgent; 1095 if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) { 1096 return true; 1097 } 1098 } 1099 catch (error) { 1100 } 1101 return false; 1102 } 1103 function isIEOrEdge() { 1104 if (isDetectedIEOrEdge) { 1105 return ieOrEdge; 1106 } 1107 isDetectedIEOrEdge = true; 1108 try { 1109 var ua = internalWindow.navigator.userAgent; 1110 if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) { 1111 ieOrEdge = true; 1112 } 1113 } 1114 catch (error) { 1115 } 1116 return ieOrEdge; 1117 } 1118 /** 1119 * @license 1120 * Copyright Google LLC All Rights Reserved. 1121 * 1122 * Use of this source code is governed by an MIT-style license that can be 1123 * found in the LICENSE file at https://angular.io/license 1124 */ 1125 Zone.__load_patch('ZoneAwarePromise', function (global, Zone, api) { 1126 var ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 1127 var ObjectDefineProperty = Object.defineProperty; 1128 function readableObjectToString(obj) { 1129 if (obj && obj.toString === Object.prototype.toString) { 1130 var className = obj.constructor && obj.constructor.name; 1131 return (className ? className : '') + ': ' + JSON.stringify(obj); 1132 } 1133 return obj ? obj.toString() : Object.prototype.toString.call(obj); 1134 } 1135 var __symbol__ = api.symbol; 1136 var _uncaughtPromiseErrors = []; 1137 var isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] === true; 1138 var symbolPromise = __symbol__('Promise'); 1139 var symbolThen = __symbol__('then'); 1140 var creationTrace = '__creationTrace__'; 1141 api.onUnhandledError = function (e) { 1142 if (api.showUncaughtError()) { 1143 var rejection = e && e.rejection; 1144 if (rejection) { 1145 console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined); 1146 } 1147 else { 1148 console.error(e); 1149 } 1150 } 1151 }; 1152 api.microtaskDrainDone = function () { 1153 var _loop_2 = function () { 1154 var uncaughtPromiseError = _uncaughtPromiseErrors.shift(); 1155 try { 1156 uncaughtPromiseError.zone.runGuarded(function () { 1157 if (uncaughtPromiseError.throwOriginal) { 1158 throw uncaughtPromiseError.rejection; 1159 } 1160 throw uncaughtPromiseError; 1161 }); 1162 } 1163 catch (error) { 1164 handleUnhandledRejection(error); 1165 } 1166 }; 1167 while (_uncaughtPromiseErrors.length) { 1168 _loop_2(); 1169 } 1170 }; 1171 var UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler'); 1172 function handleUnhandledRejection(e) { 1173 api.onUnhandledError(e); 1174 try { 1175 var handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_
1175SYMBOL]; 1176 if (typeof handler === 'function') { 1177 handler.call(this, e); 1178 } 1179 } 1180 catch (err) { 1181 } 1182 } 1183 function isThenable(value) { 1184 return value && value.then; 1185 } 1186 function forwardResolution(value) { 1187 return value; 1188 } 1189 function forwardRejection(rejection) { 1190 return ZoneAwarePromise.reject(rejection); 1191 } 1192 var symbolState = __symbol__('state'); 1193 var symbolValue = __symbol__('value'); 1194 var symbolFinally = __symbol__('finally'); 1195 var symbolParentPromiseValue = __symbol__('parentPromiseValue'); 1196 var symbolParentPromiseState = __symbol__('parentPromiseState'); 1197 var source = 'Promise.then'; 1198 var UNRESOLVED = null; 1199 var RESOLVED = true; 1200 var REJECTED = false; 1201 var REJECTED_NO_CATCH = 0; 1202 function makeResolver(promise, state) { 1203 return function (v) { 1204 try { 1205 resolvePromise(promise, state, v); 1206 } 1207 catch (err) { 1208 resolvePromise(promise, false, err); 1209 } 1210 // Do not return value or you will break the Promise spec. 1211 }; 1212 } 1213 var once = function () { 1214 var wasCalled = false; 1215 return function wrapper(wrappedFunction) { 1216 return function () { 1217 if (wasCalled) { 1218 return; 1219 } 1220 wasCalled = true; 1221 wrappedFunction.apply(null, arguments); 1222 }; 1223 }; 1224 }; 1225 var TYPE_ERROR = 'Promise resolved with itself'; 1226 var CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace'); 1227 // Promise Resolution 1228 function resolvePromise(promise, state, value) { 1229 var onceWrapper = once(); 1230 if (promise === value) { 1231 throw new TypeError(TYPE_ERROR); 1232 } 1233 if (promise[symbolState] === UNRESOLVED) { 1234 // should only get value.then once based on promise spec. 1235 var then = null; 1236 try { 1237 if (typeof value === 'object' || typeof value === 'function') { 1238 then = value && value.then; 1239 } 1240 } 1241 catch (err) { 1242 onceWrapper(function () { 1243 resolvePromise(promise, false, err); 1244 })(); 1245 return promise; 1246 } 1247 // if (value instanceof ZoneAwarePromise) { 1248 if (state !== REJECTED && value instanceof ZoneAwarePromise && 1249 value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) && 1250 value[symbolState] !== UNRESOLVED) { 1251 clearRejectedNoCatch(value); 1252 resolvePromise(promise, value[symbolState], value[symbolValue]); 1253 } 1254 else if (state !== REJECTED && typeof then === 'function') { 1255 try { 1256 then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false))); 1257 } 1258 catch (err) { 1259 onceWrapper(function () { 1260 resolvePromise(promise, false, err); 1261 })(); 1262 } 1263 } 1264 else { 1265 promise[symbolState] = state; 1266 var queue = promise[symbolValue]; 1267 promise[symbolValue] = value; 1268 if (promise[symbolFinally] === symbolFinally) { 1269 // the promise is generated by Promise.prototype.finally 1270 if (state === RESOLVED) { 1271 // the state is resolved, should ignore the value 1272 // and use parent promise value 1273 promise[symbolState] = promise[symbolParentPromiseState]; 1274 promise[symbolValue] = promise[symbolParentPromiseValue]; 1275 } 1276 } 1277 // record task information in value when error occurs, so we can
1278 // do some additional work such as render longStackTrace 1279 if (state === REJECTED && value instanceof Error) { 1280 // check if longStackTraceZone is here 1281 var trace = Zone.currentTask && Zone.currentTask.data && 1282 Zone.currentTask.data[creationTrace]; 1283 if (trace) { 1284 // only keep the long stack trace into error when in longStackTraceZone 1285 ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, { configurable: true, enumerable: false, writable: true, value: trace }); 1286 } 1287 } 1288 for (var i = 0; i < queue.length;) { 1289 scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]); 1290 } 1291 if (queue.length == 0 && state == REJECTED) { 1292 promise[symbolState] = REJECTED_NO_CATCH; 1293 var uncaughtPromiseError = value; 1294 try { 1295 // Here we throws a new Error to print more readable error log 1296 // and if the value is not an error, zone.js builds an `Error` 1297 // Object here to attach the stack information. 1298 throw new Error('Uncaught (in promise): ' + readableObjectToString(value) + 1299 (value && value.stack ? '\n' + value.stack : '')); 1300 } 1301 catch (err) { 1302 uncaughtPromiseError = err; 1303 } 1304 if (isDisableWrappingUncaughtPromiseRejection) { 1305 // If disable wrapping uncaught promise reject 1306 // use the value instead of wrapping it. 1307 uncaughtPromiseError.throwOriginal = true; 1308 } 1309 uncaughtPromiseError.rejection = value; 1310 uncaughtPromiseError.promise = promise; 1311 uncaughtPromiseError.zone = Zone.current; 1312 uncaughtPromiseError.task = Zone.currentTask; 1313 _uncaughtPromiseErrors.push(uncaughtPromiseError); 1314 api.scheduleMicroTask(); // to make sure that it is running 1315 } 1316 } 1317 } 1318 // Resolving an already resolved promise is a noop. 1319 return promise; 1320 } 1321 var REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler'); 1322 function clearRejectedNoCatch(promise) { 1323 if (promise[symbolState] === REJECTED_NO_CATCH) { 1324 // if the promise is rejected no catch status 1325 // and queue.length > 0, means there is a error handler 1326 // here to handle the rejected promise, we should trigger 1327 // windows.rejectionhandled eventHandler or nodejs rejectionHandled 1328 // eventHandler 1329 try { 1330 var handler = Zone[REJECTION_HANDLED_HANDLER]; 1331 if (handler && typeof handler === 'function') { 1332 handler.call(this, { rejection: promise[symbolValue], promise: promise }); 1333 } 1334 } 1335 catch (err) { 1336 } 1337 promise[symbolState] = REJECTED; 1338 for (var i = 0; i < _uncaughtPromiseErrors.length; i++) { 1339 if (promise === _uncaughtPromiseErrors[i].promise) { 1340 _uncaughtPromiseErrors.splice(i, 1); 1341 } 1342 } 1343 } 1344 } 1345 function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) { 1346 clearRejectedNoCatch(promise); 1347 var promiseState = promise[symbolState]; 1348 var delegate = promiseState ? 1349 (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution : 1350 (typeof onRejected === 'function') ? onRejected : 1351 forwardRejection; 1352 zone.scheduleMicroTask(source, function () { 1353 try { 1354 var parentPromiseValue = promise[symbolValue];
1355 var isFinallyPromise = !!chainPromise && symbolFinally === chainPromise[symbolFinally]; 1356 if (isFinallyPromise) { 1357 // if the promise is generated from finally call, keep parent promise's state and value 1358 chainPromise[symbolParentPromiseValue] = parentPromiseValue; 1359 chainPromise[symbolParentPromiseState] = promiseState; 1360 } 1361 // should not pass value to finally callback 1362 var value = zone.run(delegate, undefined, isFinallyPromise && delegate !== forwardRejection && delegate !== forwardResolution ? 1363 [] : 1364 [parentPromiseValue]); 1365 resolvePromise(chainPromise, true, value); 1366 } 1367 catch (error) { 1368 // if error occurs, should always return this error 1369 resolvePromise(chainPromise, false, error); 1370 } 1371 }, chainPromise); 1372 } 1373 var ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }'; 1374 var noop = function () { }; 1375 var AggregateError = global.AggregateError; 1376 var ZoneAwarePromise = /** @class */ (function () { 1377 function ZoneAwarePromise(executor) { 1378 var promise = this; 1379 if (!(promise instanceof ZoneAwarePromise)) { 1380 throw new Error('Must be an instanceof Promise.'); 1381 } 1382 promise[symbolState] = UNRESOLVED; 1383 promise[symbolValue] = []; // queue; 1384 try { 1385 var onceWrapper = once(); 1386 executor && 1387 executor(onceWrapper(makeResolver(promise, RESOLVED)), onceWrapper(makeResolver(promise, REJECTED))); 1388 } 1389 catch (error) { 1390 resolvePromise(promise, false, error); 1391 } 1392 } 1393 ZoneAwarePromise.toString = function () { 1394 return ZONE_AWARE_PROMISE_TO_STRING; 1395 }; 1396 ZoneAwarePromise.resolve = function (value) { 1397 return resolvePromise(new this(null), RESOLVED, value); 1398 }; 1399 ZoneAwarePromise.reject = function (error) { 1400 return resolvePromise(new this(null), REJECTED, error); 1401 }; 1402 ZoneAwarePromise.any = function (values) { 1403 if (!values || typeof values[Symbol.iterator] !== 'function') { 1404 return Promise.reject(new AggregateError([], 'All promises were rejected')); 1405 } 1406 var promises = []; 1407 var count = 0; 1408 try { 1409 for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { 1410 var v = values_1[_i]; 1411 count++; 1412 promises.push(ZoneAwarePromise.resolve(v)); 1413 } 1414 } 1415 catch (err) { 1416 return Promise.reject(new AggregateError([], 'All promises were rejected')); 1417 } 1418 if (count === 0) { 1419 return Promise.reject(new AggregateError([], 'All promises were rejected')); 1420 } 1421 var finished = false; 1422 var errors = []; 1423 return new ZoneAwarePromise(function (resolve, reject) { 1424 for (var i = 0; i < promises.length; i++) { 1425 promises[i].then(function (v) { 1426 if (finished) { 1427 return; 1428 } 1429 finished = true; 1430 resolve(v); 1431 }, function (err) { 1432 errors.push(err); 1433 count--; 1434 if (count === 0) { 1435 finished = true; 1436 reject(new AggregateError(errors, 'All promises were rejected')); 1437 } 1438 }); 1439 } 1440 }); 1441 }; 1442 ; 1443 ZoneAwarePromise.race = function (values) { 1444 var resolve; 1445 var reject; 1446 var promise = new this(function (res, rej) { 1447 resolve = res; 1448 reject = rej; 1449 }); 1450 function onResolve(value) { 1451 resolve(value); 1452 } 1453 function onReject(error) { 1454 reject(error); 1455 } 1456 for (var _i = 0, values_2 = values; _i < values_2.length; _i++) { 1457 var value = values_2[_i]; 1458 if (!isThenable(value)) { 1459 value = this.resolve(value); 1460 } 1461 value.then(onResolve, onReject); 1462 } 1463 return promise; 1464 }; 1465 ZoneAwarePromise.all = function (values) { 1466 return ZoneAwarePromise.allWithCallback(values); 1467 }; 1468 ZoneAwarePromise.allSettled = function (values) { 1469 var P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise; 1470 return P.allWithCallback(values, { 1471 thenCallback: function (value) { return ({ status: 'fulfilled', value: value }); }, 1472 errorCallback: function (err) { return ({ status: 'rejected', reason: err }); } 1473 }); 1474 }; 1475 ZoneAwarePromise.allWithCallback = function (values, callback) { 1476 var resolve; 1477 var reject; 1478 var promise = new this(function (res, rej) { 1479 resolve = res; 1480 reject = rej; 1481 }); 1482 // Start at 2 to prevent prematurely resolving if .then is called
1482immediately. 1483 var unresolvedCount = 2; 1484 var valueIndex = 0; 1485 var resolvedValues = []; 1486 var _loop_3 = function (value) { 1487 if (!isThenable(value)) { 1488 value = this_1.resolve(value); 1489 } 1490 var curValueIndex = valueIndex; 1491 try { 1492 value.then(function (value) { 1493 resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value; 1494 unresolvedCount--; 1495 if (unresolvedCount === 0) { 1496 resolve(resolvedValues); 1497 } 1498 }, function (err) { 1499 if (!callback) { 1500 reject(err); 1501 } 1502 else { 1503 resolvedValues[curValueIndex] = callback.errorCallback(err); 1504 unresolvedCount--; 1505 if (unresolvedCount === 0) { 1506 resolve(resolvedValues); 1507 } 1508 } 1509 }); 1510 } 1511 catch (thenErr) { 1512 reject(thenErr); 1513 } 1514 unresolvedCount++; 1515 valueIndex++; 1516 }; 1517 var this_1 = this; 1518 for (var _i = 0, values_3 = values; _i < values_3.length; _i++) { 1519 var value = values_3[_i]; 1520 _loop_3(value); 1521 } 1522 // Make the unresolvedCount zero-based again. 1523 unresolvedCount -= 2; 1524 if (unresolvedCount === 0) { 1525 resolve(resolvedValues); 1526 } 1527 return promise; 1528 }; 1529 Object.defineProperty(ZoneAwarePromise.prototype, Symbol.toStringTag, { 1530 get: function () { 1531 return 'Promise'; 1532 }, 1533 enumerable: false, 1534 configurable: true 1535 }); 1536 Object.defineProperty(ZoneAwarePromise.prototype, Symbol.species, { 1537 get: function () { 1538 return ZoneAwarePromise; 1539 }, 1540 enumerable: false, 1541 configurable: true 1542 }); 1543 ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) { 1544 var _a; 1545 // We must read `Symbol.species` safely because `this` may be anything. For instance, `this` 1546 // may be an object without a prototype (created through `Object.create(null)`); thus 1547 // `this.constructor` will be undefined. One of the use cases is SystemJS creating 1548 // prototype-less objects (modules) via `Object.create(null)`. The SystemJS creates an empty 1549 // object and copies promise properties into that object (within the `getOrCreateLoad` 1550 // function). The zone.js then checks if the resolved value has the `then` method and invokes 1551 // it with the `value` context. Otherwise, this will throw an error: `TypeError: Cannot read 1552 // properties of undefined (reading 'Symbol(Symbol.species)')`. 1553 var C = (_a = this.constructor) === null || _a === void 0 ? void 0 : _a[Symbol.species]; 1554 if (!C || typeof C !== 'function') { 1555 C = this.constructor || ZoneAwarePromise; 1556 } 1557 var chainPromise = new C(noop); 1558 var zone = Zone.current; 1559 if (this[symbolState] == UNRESOLVED) { 1560 this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected); 1561 } 1562 else { 1563 scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected); 1564 }
1565 return chainPromise; 1566 }; 1567 ZoneAwarePromise.prototype.catch = function (onRejected) { 1568 return this.then(null, onRejected); 1569 }; 1570 ZoneAwarePromise.prototype.finally = function (onFinally) { 1571 var _a; 1572 // See comment on the call to `then` about why thee `Symbol.species` is safely accessed. 1573 var C = (_a = this.constructor) === null || _a === void 0 ? void 0 : _a[Symbol.species]; 1574 if (!C || typeof C !== 'function') { 1575 C = ZoneAwarePromise; 1576 } 1577 var chainPromise = new C(noop); 1578 chainPromise[symbolFinally] = symbolFinally; 1579 var zone = Zone.current; 1580 if (this[symbolState] == UNRESOLVED) { 1581 this[symbolValue].push(zone, chainPromise, onFinally, onFinally); 1582 } 1583 else { 1584 scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally); 1585 }
1586 return chainPromise; 1587 }; 1588 return ZoneAwarePromise; 1589 }()); 1590 // Protect against aggressive optimizers dropping seemingly unused properties. 1591 // E.g. Closure Compiler in advanced mode. 1592 ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve; 1593 ZoneAwarePromise['reject'] = ZoneAwarePromise.reject; 1594 ZoneAwarePromise['race'] = ZoneAwarePromise.race; 1595 ZoneAwarePromise['all'] = ZoneAwarePromise.all; 1596 var NativePromise = global[symbolPromise] = global['Promise']; 1597 global['Promise'] = ZoneAwarePromise; 1598 var symbolThenPatched = __symbol__('thenPatched'); 1599 function patchThen(Ctor) { 1600 var proto = Ctor.prototype; 1601 var prop = ObjectGetOwnPropertyDescriptor(proto, 'then'); 1602 if (prop && (prop.writable === false || !prop.configurable)) { 1603 // check Ctor.prototype.then propertyDescriptor is writable or not 1604 // in meteor env, writable is false, we should ignore such case 1605 return; 1606 } 1607 var originalThen = proto.then; 1608 // Keep a reference to the original method. 1609 proto[symbolThen] = originalThen; 1610 Ctor.prototype.then = function (onResolve, onReject) { 1611 var _this = this; 1612 var wrapped = new ZoneAwarePromise(function (resolve, reject) { 1613 originalThen.call(_this, resolve, reject); 1614 }); 1615 return wrapped.then(onResolve, onReject); 1616 }; 1617 Ctor[symbolThenPatched] = true; 1618 } 1619 api.patchThen = patchThen; 1620 function zoneify(fn) { 1621 return function (self, args) { 1622 var resultPromise = fn.apply(self, args); 1623 if (resultPromise instanceof ZoneAwarePromise) { 1624 return resultPromise; 1625 } 1626 var ctor = resultPromise.constructor; 1627 if (!ctor[symbolThenPatched]) { 1628 patchThen(ctor); 1629 } 1630 return resultPromise; 1631 }; 1632 } 1633 if (NativePromise) { 1634 patchThen(NativePromise); 1635 patchMethod(global, 'fetch', function (delegate) { return zoneify(delegate); }); 1636 } 1637 // This is not part of public API, but it is useful for tests, so we expose it. 1638 Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors; 1639 return ZoneAwarePromise; 1640 }); 1641 /** 1642 * @license 1643 * Copyright Google LLC All Rights Reserved. 1644 * 1645 * Use of this source code is governed by an MIT-style license that can be 1646 * found in the LICENSE file at https://angular.io/license 1647 */ 1648 // override Function.prototype.toString to make zone.js patched function 1649 // look like native function 1650 Zone.__load_patch('toString', function (global) { 1651 // patch Func.prototype.toString to let them look like native 1652 var originalFunctionToString = Function.prototype.toString; 1653 var ORIGINAL_DELEGATE_SYMBOL = zoneSymbol$1('OriginalDelegate'); 1654 var PROMISE_SYMBOL = zoneSymbol$1('Promise'); 1655 var ERROR_SYMBOL = zoneSymbol$1('Error'); 1656 var newFunctionToString = function toString() { 1657 if (typeof this === 'function') { 1658 var originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL]; 1659 if (originalDelegate) { 1660 if (typeof originalDelegate === 'function') { 1661 return originalFunctionToString.call(originalDelegate); 1662 } 1663 else { 1664 return Object.prototype.toString.call(originalDelegate); 1665 } 1666 } 1667 if (this === Promise) { 1668 var nativePromise = global[PROMISE_SYMBOL]; 1669 if (nativePromise) { 1670 return originalFunctionToString.call(nativePromise); 1671 } 1672 } 1673 if (this === Error) { 1674 var nativeError = global[ERROR_SYMBOL]; 1675 if (nativeError) { 1676 return originalFunctionToString.call(nativeError); 1677 } 1678 } 1679 } 1680 return originalFunctionToString.call(this); 1681 }; 1682 newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString; 1683 Function.prototype.toString = newFunctionToString; 1684 // patch Object.prototype.toString to let them look like native 1685 var originalObjectToString = Object.prototype.toString; 1686 var PROMISE_OBJECT_TO_STRING = '[object Promise]'; 1687 Object.prototype.toString = function () { 1688 if (typeof Promise === 'function' && this instanceof Promise) { 1689 return PROMISE_OBJECT_TO_STRING; 1690 } 1691 return originalObjectToString.call(this); 1692 }; 1693 }); 1694 /** 1695 * @license 1696 * Copyright Google LLC All Rights Reserved. 1697 * 1698 * Use of this source code is governed by an MIT-style license that can be 1699 * found in the LICENSE file at https://angular.io/license 1700 */ 1701 var passiveSupported = false;
1702 if (typeof window !== 'undefined') { 1703 try { 1704 var options = Object.defineProperty({}, 'passive', { 1705 get: function () { 1706 passiveSupported = true; 1707 } 1708 }); 1709 // Note: We pass the `options` object as the event handler too. This is not compatible with the 1710 // signature of `addEventListener` or `removeEventListener` but enables us to remove the handler 1711 // without an actual handler. 1712 window.addEventListener('test', options, options); 1713 window.removeEventListener('test', options, options); 1714 } 1715 catch (err) { 1716 passiveSupported = false; 1717 } 1718 } 1719 // an identifier to tell ZoneTask do not create a new invoke closure 1720 var OPTIMIZED_ZONE_EVENT_TASK_DATA = { 1721 useG: true 1722 }; 1723 var zoneSymbolEventNames = {}; 1724 var globalSources = {}; 1725 var EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\w+)(true|false)$'); 1726 var IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol$1('propagationStopped'); 1727 function prepareEventNames(eventName, eventNameToString) { 1728 var falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR; 1729 var trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR; 1730 var symbol = ZONE_SYMBOL_PREFIX + falseEventName; 1731 var symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName; 1732 zoneSymbolEventNames[eventName] = {}; 1733 zoneSymbolEventNames[eventName][FALSE_STR] = symbol; 1734 zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture; 1735 } 1736 function patchEventTarget(_global, api, apis, patchOptions) { 1737 var ADD_EVENT_LISTENER = (patchOptions && patchOptions.add) || ADD_EVENT_LISTENER_STR; 1738 var REMOVE_EVENT_LISTENER = (patchOptions && patchOptions.rm) || REMOVE_EVENT_LISTENER_STR; 1739 var LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.listeners) || 'eventListeners'; 1740 var REMOVE_ALL_LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.rmAll) || 'removeAllListeners'; 1741 var zoneSymbolAddEventListener = zoneSymbol$1(ADD_EVENT_LISTENER); 1742 var ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':'; 1743 var PREPEND_EVENT_LISTENER = 'prependListener'; 1744 var PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':'; 1745 var invokeTask = function (task, target, event) { 1746 // for better performance, check isRemoved which is set 1747 // by removeEventListener 1748 if (task.isRemoved) { 1749 return; 1750 } 1751 var delegate = task.callback; 1752 if (typeof delegate === 'object' && delegate.handleEvent) { 1753 // create the bind version of handleEvent when invoke 1754 task.callback = function (event) { return delegate.handleEvent(event); }; 1755 task.originalDelegate = delegate; 1756 } 1757 // invoke static task.invoke 1758 // need to try/catch error here, otherwise, the error in one event listener 1759 // will break the executions of the other event listeners. Also error will 1760 // not remove the event listener when `once` options is true. 1761 var error; 1762 try { 1763 task.invoke(task, target, [event]); 1764 } 1765 catch (err) { 1766 error = err; 1767 } 1768 var options = task.options; 1769 if (options && typeof options === 'object' && options.once) { 1770 // if options.once is true, after invoke once remove listener here 1771 // only browser need to do this, nodejs eventEmitter will cal removeListener 1772 // inside EventEmitter.once 1773 var delegate_1 = task.originalDelegate ? task.originalDelegate : task.callback; 1774 target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate_1, options); 1775 } 1776 return error; 1777 }; 1778 function globalCallback(context, event, isCapture) { 1779 // https://github.com/angular/zone.js/issues/911, in IE, sometimes 1780 // event will be undefined, so we need to use window.event 1781 event = event || _global.event; 1782 if (!event) { 1783 return; 1784 } 1785 // event.target is needed for Samsung TV and SourceBuffer 1786 // || global is needed https://github.com/angular/zone.js/issues/190 1787 var target = context || event.target || _global; 1788 var tasks = target[zoneSymbolEventNames[event.type][isCapture ? TRUE_STR : FALSE_STR]]; 1789 if (tasks) { 1790 var errors = []; 1791 // invoke all tasks which attached to current target with given event.type and capture = false 1792 // for performance concern, if task.length === 1, just invoke 1793 if (tasks.length === 1) { 1794 var err = invokeTask(tasks[0], target, event); 1795 err && errors.push(err); 1796 } 1797 else { 1798 // https://github.com/angular/zone.js/issues/836 1799 // copy the tasks array before invoke, to avoid 1800 // the callback will remove itself or other listener 1801 var copyTasks = tasks.slice(); 1802 for (var i = 0; i < copyTasks.length; i++) { 1803 if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) { 1804 break; 1805 } 1806 var err = invokeTask(copyTasks[i], target, event); 1807 err && errors.push(err); 1808 } 1809 } 1810 // Since there is only one error, we don't need to schedule microTask 1811 // to throw the error. 1812 if (errors.length === 1) { 1813 throw errors[0]; 1814 } 1815 else { 1816 var _loop_4 = function (i) { 1817 var err = errors[i]; 1818 api.nativeScheduleMicroTask(function () { 1819 throw err; 1820 }); 1821 }; 1822 for (var i = 0; i < errors.length; i++) { 1823 _loop_4(i); 1824 } 1825 } 1826 } 1827 } 1828 // global shared zoneAwareCallback to handle all event callback with capture = false 1829 var globalZoneAwareCallback = function (event) { 1830 return globalCallback(this, event, false); 1831 }; 1832 // global shared zoneAwareCallback to handle all event callback with capture = true 1833 var globalZoneAwareCaptureCallback = function (event) { 1834 return globalCallback(this, event, true); 1835 }; 1836 function patchEventTargetMethods(obj, patchOptions) { 1837 if (!obj) { 1838 return false;
1839 } 1840 var useGlobalCallback = true; 1841 if (patchOptions && patchOptions.useG !== undefined) { 1842 useGlobalCallback = patchOptions.useG; 1843 } 1844 var validateHandler = patchOptions && patchOptions.vh; 1845 var checkDuplicate = true; 1846 if (patchOptions && patchOptions.chkDup !== undefined) { 1847 checkDuplicate = patchOptions.chkDup; 1848 } 1849 var returnTarget = false; 1850 if (patchOptions && patchOptions.rt !== undefined) { 1851 returnTarget = patchOptions.rt; 1852 } 1853 var proto = obj; 1854 while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) { 1855 proto = ObjectGetPrototypeOf(proto); 1856 } 1857 if (!proto && obj[ADD_EVENT_LISTENER]) { 1858 // somehow we did not find it, but we can see it. This happens on IE for Window properties. 1859 proto = obj; 1860 } 1861 if (!proto) { 1862 return false; 1863 } 1864 if (proto[zoneSymbolAddEventListener]) { 1865 return false; 1866 } 1867 var eventNameToString = patchOptions && patchOptions.eventNameToString; 1868 // a shared global taskData to pass data for scheduleEventTask 1869 // so we do not need to create a new object just for pass some data 1870 var taskData = {}; 1871 var nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER]; 1872 var nativeRemoveEventListener = proto[zoneSymbol$1(REMOVE_EVENT_LISTENER)] = 1873 proto[REMOVE_EVENT_LISTENER]; 1874 var nativeListeners = proto[zoneSymbol$1(LISTENERS_EVENT_LISTENER)] = 1875 proto[LISTENERS_EVENT_LISTENER]; 1876 var nativeRemoveAllListeners = proto[zoneSymbol$1(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] = 1877 proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER]; 1878 var nativePrependEventListener; 1879 if (patchOptions && patchOptions.prepend) { 1880 nativePrependEventListener = proto[zoneSymbol$1(patchOptions.prepend)] = 1881 proto[patchOptions.prepend]; 1882 } 1883 /** 1884 * This util function will build an option object with passive option 1885 * to handle all possible input from the user. 1886 */ 1887 function buildEventListenerOptions(options, passive) { 1888 if (!passiveSupported && typeof options === 'object' && options) { 1889 // doesn't support passive but user want to pass an object as options. 1890 // this will not work on some old browser, so we just pass a boolean 1891 // as useCapture parameter 1892 return !!options.capture; 1893 } 1894 if (!passiveSupported || !passive) { 1895 return options; 1896 } 1897 if (typeof options === 'boolean') { 1898 return { capture: options, passive: true }; 1899 } 1900 if (!options) { 1901 return { passive: true }; 1902 } 1903 if (typeof options === 'object' && options.passive !== false) { 1904 return Object.assign(Object.assign({}, options), { passive: true }); 1905 } 1906 return options; 1907 } 1908 var customScheduleGlobal = function (task) { 1909 // if there is already a task for the eventName + capture, 1910 // just return, because we use the shared globalZoneAwareCallback here. 1911 if (taskData.isExisting) { 1912 return; 1913 } 1914 return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options); 1915 }; 1916 var customCancelGlobal = function (task) { 1917 // if task is not marked as isRemoved, this call is directly 1918 // from Zone.prototype.cancelTask, we should remove the task 1919 // from tasksList of target first 1920 if (!task.isRemoved) { 1921 var symbolEventNames = zoneSymbolEventNames[task.eventName]; 1922 var symbolEventName = void 0; 1923 if (symbolEventNames) { 1924 symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR]; 1925 } 1926 var existingTasks = symbolEventName && task.target[symbolEventName]; 1927 if (existingTasks) { 1928 for (var i = 0; i < existingTasks.length; i++) { 1929 var existingTask = existingTasks[i]; 1930 if (existingTask === task) { 1931 existingTasks.splice(i, 1); 1932 // set isRemoved to data for faster invokeTask check 1933 task.isRemoved = true; 1934 if (existingTasks.length === 0) { 1935 // all tasks for the eventName + capture have gone, 1936 // remove globalZoneAwareCallback and remove the task cache from target 1937 task.allRemoved = true; 1938 task.target[symbolEventName] = null; 1939 } 1940 break; 1941 } 1942 } 1943 } 1944 } 1945 // if all tasks for the eventName + capture have gone, 1946 // we will really remove the global event callback, 1947 // if not, return 1948 if (!task.allRemoved) { 1949 return; 1950 } 1951 return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options); 1952 }; 1953 var customScheduleNonGlobal = function (task) { 1954 return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options); 1955 }; 1956 var customSchedulePrepend = function (task) { 1957 return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options); 1958 }; 1959 var customCancelNonGlobal = function (task) { 1960 return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options); 1961 }; 1962 var customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal; 1963 var customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal; 1964 var compareTaskCallbackVsDelegate = function (task, delegate) { 1965 var typeOfDelegate = typeof delegate; 1966 return (typeOfDelegate === 'function' && task.callback === delegate) || 1967 (typeOfDelegate === 'object' && task.originalDelegate === delegate); 1968 }; 1969 var compare = (patchOptions && patchOptions.diff) ? patchOptions.diff : compareTaskCallbackVsDelegate; 1970 var unpatchedEvents = Zone[zoneSymbol$1('UNPATCHED_EVENTS')]; 1971 var passiveEvents = _global[zoneSymbol$1('PASSIVE_EVENTS')]; 1972 var makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget, prepend) { 1973 if (returnTarget === void 0) { returnTarget = false; } 1974 if (prepend === void 0) { prepend = false; } 1975 return function () { 1976 var target = this || _global; 1977 var eventName = arguments[0]; 1978 if (patchOptions && patchOptions.transferEventName) { 1979 eventName = patchOptions.transferEventName(eventName); 1980 } 1981 var delegate = arguments[1]; 1982 if (!delegate) { 1983 return nativeListener.apply(this, arguments); 1984 } 1985 if (isNode && eventName === 'uncaughtException') { 1986 // don't patch uncaughtException of nodejs to prevent endless loop 1987 return nativeListener.apply(this, arguments); 1988 } 1989 // don't create the bind delegate function for handleEvent 1990 // case here to improve addEventListener performance 1991 // we will create the bind delegate when invoke 1992 var isHandleEvent = false;
1993 if (typeof delegate !== 'function') { 1994 if (!delegate.handleEvent) { 1995 return nativeListener.apply(this, arguments); 1996 } 1997 isHandleEvent = true; 1998 } 1999 if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) { 2000 return; 2001 } 2002 var passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1; 2003 var options = buildEventListenerOptions(arguments[2], passive); 2004 if (unpatchedEvents) { 2005 // check unpatched list 2006 for (var i = 0; i < unpatchedEvents.length; i++) { 2007 if (eventName === unpatchedEvents[i]) { 2008 if (passive) { 2009 return nativeListener.call(target, eventName, delegate, options); 2010 } 2011 else { 2012 return nativeListener.apply(this, arguments); 2013 } 2014 } 2015 } 2016 } 2017 var capture = !options ? false : typeof options === 'boolean' ? true : options.capture; 2018 var once = options && typeof options === 'object' ? options.once : false; 2019 var zone = Zone.current; 2020 var symbolEventNames = zoneSymbolEventNames[eventName]; 2021 if (!symbolEventNames) { 2022 prepareEventNames(eventName, eventNameToString); 2023 symbolEventNames = zoneSymbolEventNames[eventName]; 2024 } 2025 var symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR]; 2026 var existingTasks = target[symbolEventName]; 2027 var isExisting = false; 2028 if (existingTasks) { 2029 // already have task registered 2030 isExisting = true; 2031 if (checkDuplicate) { 2032 for (var i = 0; i < existingTasks.length; i++) { 2033 if (compare(existingTasks[i], delegate)) { 2034 // same callback, same capture, same event name, just return 2035 return; 2036 } 2037 } 2038 } 2039 } 2040 else { 2041 existingTasks = target[symbolEventName] = []; 2042 } 2043 var source; 2044 var constructorName = target.constructor['name']; 2045 var targetSource = globalSources[constructorName]; 2046 if (targetSource) { 2047 source = targetSource[eventName]; 2048 } 2049 if (!source) { 2050 source = constructorName + addSource + 2051 (eventNameToString ? eventNameToString(eventName) : eventName); 2052 } 2053 // do not create a new object as task.data to pass those things 2054 // just use the global shared one 2055 taskData.options = options; 2056 if (once) { 2057 // if addEventListener with once options, we don't pass it to 2058 // native addEventListener, instead we keep the once setting 2059 // and handle ourselves. 2060 taskData.options.once = false; 2061 } 2062 taskData.target = target; 2063 taskData.capture = capture; 2064 taskData.eventName = eventName; 2065 taskData.isExisting = isExisting; 2066 var data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined; 2067 // keep taskData into data to allow onScheduleEventTask to access the task information 2068 if (data) { 2069 data.taskData = taskData; 2070 } 2071 var task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn); 2072 // should clear taskData.target to avoid memory leak 2073 // issue, https://github.com/angular/angular/issues/20442 2074 taskData.target = null; 2075 // need to clear up taskData because it is a global object 2076 if (data) { 2077 data.taskData = null; 2078 } 2079 // have to save those information to task in case 2080 // application may call task.zone.cancelTask() directly 2081 if (once) { 2082 options.once = true; 2083 } 2084 if (!(!passiveSupported && typeof task.options === 'boolean')) { 2085 // if not support passive, and we pass an option object 2086 // to addEventListener, we should save the options to task 2087 task.options = options; 2088 } 2089 task.target = target; 2090 task.capture = capture; 2091 task.eventName = eventName; 2092 if (isHandleEvent) { 2093 // save original delegate for compare to check duplicate 2094 task.originalDelegate = delegate; 2095 } 2096 if (!prepend) { 2097 existingTasks.push(task); 2098 } 2099 else { 2100 existingTasks.unshift(task); 2101 } 2102 if (returnTarget) { 2103 return target; 2104 } 2105 }; 2106 }; 2107 proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget); 2108 if (nativePrependEventListener) { 2109 proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true); 2110 } 2111 proto[REMOVE_EVENT_LISTENER] = function () { 2112 var target = this || _global; 2113 var eventName = arguments[0]; 2114 if (patchOptions && patchOptions.transferEventName) { 2115 eventName = patchOptions.transferEventName(eventName); 2116 } 2117 var options = arguments[2]; 2118 var capture = !options ? false : typeof options === 'boolean' ? true : options.capture; 2119 var delegate = arguments[1]; 2120 if (!delegate) { 2121 return nativeRemoveEventListener.apply(this, arguments); 2122 } 2123 if (validateHandler && 2124 !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) { 2125 return; 2126 } 2127 var symbolEventNames = zoneSymbolEventNames[eventName]; 2128 var symbolEventName; 2129 if (symbolEventNames) { 2130 symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR]; 2131 } 2132 var existingTasks = symbolEventName && target[symbolEventName]; 2133 if (existingTasks) { 2134 for (var i = 0; i < existingTasks.length; i++) { 2135 var existingTask = existingTasks[i]; 2136 if (compare(existingTask, delegate)) { 2137 existingTasks.splice(i, 1); 2138 // set isRemoved to data for faster invokeTask check 2139 existingTask.isRemoved = true; 2140 if (existingTasks.length === 0) { 2141 // all tasks for the eventName + capture have gone, 2142 // remove globalZoneAwareCallback and remove the task cache from target 2143 existingTask.allRemoved = true; 2144 target[symbolEventName] = null; 2145 // in the target, we have an event listener which is added by on_property 2146 // such as target.onclick = function() {}, so we need to clear this internal 2147 // property too if all delegates all removed 2148 if (typeof eventName === 'string') { 2149 var onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName; 2150 target[onPropertySymbol] = null; 2151 } 2152 } 2153 existingTask.zone.cancelTask(existingTask); 2154 if (returnTarget) { 2155 return target; 2156 } 2157 return; 2158 } 2159 } 2160 } 2161 // issue 930, didn't find the event name or callback 2162 // from zone kept existingTasks, the callback maybe 2163 // added outside of zone, we need to call native removeEventListener 2164 // to try to remove it. 2165 return nativeRemoveEventListener.apply(this, arguments); 2166 };
2167 proto[LISTENERS_EVENT_LISTENER] = function () { 2168 var target = this || _global; 2169 var eventName = arguments[0]; 2170 if (patchOptions && patchOptions.transferEventName) { 2171 eventName = patchOptions.transferEventName(eventName); 2172 } 2173 var listeners = []; 2174 var tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName); 2175 for (var i = 0; i < tasks.length; i++) { 2176 var task = tasks[i]; 2177 var delegate = task.originalDelegate ? task.originalDelegate : task.callback; 2178 listeners.push(delegate); 2179 } 2180 return listeners; 2181 }; 2182 proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () { 2183 var target = this || _global; 2184 var eventName = arguments[0]; 2185 if (!eventName) { 2186 var keys = Object.keys(target); 2187 for (var i = 0; i < keys.length; i++) { 2188 var prop = keys[i]; 2189 var match = EVENT_NAME_SYMBOL_REGX.exec(prop); 2190 var evtName = match && match[1]; 2191 // in nodejs EventEmitter, removeListener event is 2192 // used for monitoring the removeListener call, 2193 // so just keep removeListener eventListener until 2194 // all other eventListeners are removed 2195 if (evtName && evtName !== 'removeListener') { 2196 this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName); 2197 } 2198 } 2199 // remove removeListener listener finally 2200 this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener'); 2201 } 2202 else { 2203 if (patchOptions && patchOptions.transferEventName) { 2204 eventName = patchOptions.transferEventName(eventName); 2205 } 2206 var symbolEventNames = zoneSymbolEventNames[eventName]; 2207 if (symbolEventNames) { 2208 var symbolEventName = symbolEventNames[FALSE_STR]; 2209 var symbolCaptureEventName = symbolEventNames[TRUE_STR]; 2210 var tasks = target[symbolEventName]; 2211 var captureTasks = target[symbolCaptureEventName]; 2212 if (tasks) { 2213 var removeTasks = tasks.slice(); 2214 for (var i = 0; i < removeTasks.length; i++) { 2215 var task = removeTasks[i]; 2216 var delegate = task.originalDelegate ? task.originalDelegate : task.callback; 2217 this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options); 2218 } 2219 } 2220 if (captureTasks) { 2221 var removeTasks = captureTasks.slice(); 2222 for (var i = 0; i < removeTasks.length; i++) { 2223 var task = removeTasks[i]; 2224 var delegate = task.originalDelegate ? task.originalDelegate : task.callback; 2225 this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options); 2226 } 2227 } 2228 } 2229 } 2230 if (returnTarget) { 2231 return this; 2232 } 2233 }; 2234 // for native toString patch 2235 attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener); 2236 attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener); 2237 if (nativeRemoveAllListeners) { 2238 attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners); 2239 } 2240 if (nativeListeners) {
2241 attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners); 2242 } 2243 return true; 2244 } 2245 var results = []; 2246 for (var i = 0; i < apis.length; i++) { 2247 results[i] = patchEventTargetMethods(apis[i], patchOptions); 2248 } 2249 return results; 2250 } 2251 function findEventTasks(target, eventName) { 2252 if (!eventName) { 2253 var foundTasks = []; 2254 for (var prop in target) { 2255 var match = EVENT_NAME_SYMBOL_REGX.exec(prop); 2256 var evtName = match && match[1]; 2257 if (evtName && (!eventName || evtName === eventName)) { 2258 var tasks = target[prop]; 2259 if (tasks) { 2260 for (var i = 0; i < tasks.length; i++) { 2261 foundTasks.push(tasks[i]); 2262 } 2263 } 2264 } 2265 } 2266 return foundTasks; 2267 } 2268 var symbolEventName = zoneSymbolEventNames[eventName]; 2269 if (!symbolEventName) { 2270 prepareEventNames(eventName); 2271 symbolEventName = zoneSymbolEventNames[eventName]; 2272 } 2273 var captureFalseTasks = target[symbolEventName[FALSE_STR]]; 2274 var captureTrueTasks = target[symbolEventName[TRUE_STR]]; 2275 if (!captureFalseTasks) { 2276 return captureTrueTasks ? captureTrueTasks.slice() : []; 2277 } 2278 else { 2279 return captureTrueTasks ? captureFalseTasks.concat(captureTrueTasks) : 2280 captureFalseTasks.slice(); 2281 } 2282 } 2283 function patchEventPrototype(global, api) { 2284 var Event = global['Event']; 2285 if (Event && Event.prototype) { 2286 api.patchMethod(Event.prototype, 'stopImmediatePropagation', function (delegate) { return function (self, args) { 2287 self[IMMEDIATE_PROPAGATION_SYMBOL] = true; 2288 // we need to call the native stopImmediatePropagation 2289 // in case in some hybrid application, some part of 2290 // application will be controlled by zone, some are not 2291 delegate && delegate.apply(self, args); 2292 }; }); 2293 } 2294 } 2295 /** 2296 * @license 2297 * Copyright Google LLC All Rights Reserved. 2298 * 2299 * Use of this source code is governed by an MIT-style license that can be 2300 * found in the LICENSE file at https://angular.io/license 2301 */ 2302 function patchCallbacks(api, target, targetName, method, callbacks) { 2303 var symbol = Zone.__symbol__(method); 2304 if (target[symbol]) { 2305 return; 2306 } 2307 var nativeDelegate = target[symbol] = target[method]; 2308 target[method] = function (name, opts, options) { 2309 if (opts && opts.prototype) { 2310 callbacks.forEach(function (callback) { 2311 var source = "".concat(targetName, ".").concat(method, "::") + callback; 2312 var prototype = opts.prototype; 2313 // Note: the `patchCallbacks` is used for patching the `document.registerElement` and 2314 // `customElements.define`. We explicitly wrap the patching code into try-catch since 2315 // callbacks may be already patched by other web components frameworks (e.g. LWC), and they 2316 // make those properties non-writable. This means that patching callback will throw an error 2317 // `cannot assign to read-only property`. See this code as an example: 2318 // https://github.com/salesforce/lwc/blob/master/packages/@lwc/engine-core/src/framework/base-bridge-element.ts#L180-L186 2319 // We don't want to stop the application rendering if we couldn't patch some 2320 // callback, e.g. `attributeChangedCallback`. 2321 try { 2322 if (prototype.hasOwnProperty(callback)) { 2323 var descriptor = api.ObjectGetOwnPropertyDescriptor(prototype, callback); 2324 if (descriptor && descriptor.value) { 2325 descriptor.value = api.wrapWithCurrentZone(descriptor.value, source); 2326 api._redefineProperty(opts.prototype, callback, descriptor); 2327 } 2328 else if (prototype[callback]) { 2329 prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source); 2330 } 2331 } 2332 else if (prototype[callback]) { 2333 prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source); 2334 } 2335 } 2336 catch (_a) {
2337 // Note: we leave the catch block empty since there's no way to handle the error related 2338 // to non-writable property. 2339 } 2340 }); 2341 } 2342 return nativeDelegate.call(target, name, opts, options); 2343 }; 2344 api.attachOriginToPatched(target[method], nativeDelegate); 2345 } 2346 /** 2347 * @license 2348 * Copyright Google LLC All Rights Reserved. 2349 * 2350 * Use of this source code is governed by an MIT-style license that can be 2351 * found in the LICENSE file at https://angular.io/license 2352 */ 2353 function filterProperties(target, onProperties, ignoreProperties) { 2354 if (!ignoreProperties || ignoreProperties.length === 0) { 2355 return onProperties; 2356 } 2357 var tip = ignoreProperties.filter(function (ip) { return ip.target === target; }); 2358 if (!tip || tip.length === 0) { 2359 return onProperties; 2360 } 2361 var targetIgnoreProperties = tip[0].ignoreProperties; 2362 return onProperties.filter(function (op) { return targetIgnoreProperties.indexOf(op) === -1; }); 2363 } 2364 function patchFilteredProperties(target, onProperties, ignoreProperties, prototype) { 2365 // check whether target is available, sometimes target will be undefined 2366 // because different browser or some 3rd party plugin. 2367 if (!target) { 2368 return; 2369 } 2370 var filteredProperties = filterProperties(target, onProperties, ignoreProperties); 2371 patchOnProperties(target, filteredProperties, prototype); 2372 } 2373 /** 2374 * Get all event name properties which the event name startsWith `on` 2375 * from the target object itself, inherited properties are not considered. 2376 */ 2377 function getOnEventNames(target) { 2378 return Object.getOwnPropertyNames(target) 2379 .filter(function (name) { return name.startsWith('on') && name.length > 2; }) 2380 .map(function (name) { return name.substring(2); }); 2381 } 2382 function propertyDescriptorPatch(api, _global) { 2383 if (isNode && !isMix) { 2384 return; 2385 } 2386 if (Zone[api.symbol('patchEvents')]) { 2387 // events are already been patched by legacy patch. 2388 return; 2389 } 2390 var ignoreProperties = _global['__Zone_ignore_on_properties']; 2391 // for browsers that we can patch the descriptor: Chrome & Firefox 2392 var patchTargets = []; 2393 if (isBrowser) { 2394 var internalWindow_1 = window; 2395 patchTargets = patchTargets.concat([ 2396 'Document', 'SVGElement', 'Element', 'HTMLElement', 'HTMLBodyElement', 'HTMLMediaElement', 2397 'HTMLFrameSetElement', 'HTMLFrameElement', 'HTMLIFrameElement', 'HTMLMarqueeElement', 'Worker' 2398 ]); 2399 var ignoreErrorProperties = isIE() ? [{ target: internalWindow_1, ignoreProperties: ['error'] }] : []; 2400 // in IE/Edge, onProp not exist in window object, but in WindowPrototype 2401 // so we need to pass WindowPrototype to check onProp exist or not 2402 patchFilteredProperties(internalWindow_1, getOnEventNames(internalWindow_1), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow_1)); 2403 } 2404 patchTargets = patchTargets.concat([ 2405 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'IDBIndex', 'IDBRequest', 'IDBOpenDBRequest', 2406 'IDBDatabase', 'IDBTransaction', 'IDBCursor', 'WebSocket' 2407 ]); 2408 for (var i = 0; i < patchTargets.length; i++) { 2409 var target = _global[patchTargets[i]]; 2410 target && target.prototype && 2411 patchFilteredProperties(target.prototype, getOnEventNames(target.prototype), ignoreProperties); 2412 } 2413 } 2414 /** 2415 * @license 2416 * Copyright Google LLC All Rights Reserved. 2417 * 2418 * Use of this source code is governed by an MIT-style license that can be 2419 * found in the LICENSE file at https://angular.io/license 2420 */ 2421 Zone.__load_patch('util', function (global, Zone, api) { 2422 // Collect native event names by looking at properties
2423 // on the global namespace, e.g. 'onclick'. 2424 var eventNames = getOnEventNames(global); 2425 api.patchOnProperties = patchOnProperties; 2426 api.patchMethod = patchMethod; 2427 api.bindArguments = bindArguments; 2428 api.patchMacroTask = patchMacroTask; 2429 // In earlier version of zone.js (<0.9.0), we use env name `__zone_symbol__BLACK_LISTED_EVENTS` to 2430 // define which events will not be patched by `Zone.js`. 2431 // In newer version (>=0.9.0), we change the env name to `__zone_symbol__UNPATCHED_EVENTS` to keep 2432 // the name consistent with angular repo. 2433 // The `__zone_symbol__BLACK_LISTED_EVENTS` is deprecated, but it is still be supported for 2434 // backwards compatibility. 2435 var SYMBOL_BLACK_LISTED_EVENTS = Zone.__symbol__('BLACK_LISTED_EVENTS'); 2436 var SYMBOL_UNPATCHED_EVENTS = Zone.__symbol__('UNPATCHED_EVENTS'); 2437 if (global[SYMBOL_UNPATCHED_EVENTS]) { 2438 global[SYMBOL_BLACK_LISTED_EVENTS] = global[SYMBOL_UNPATCHED_EVENTS]; 2439 } 2440 if (global[SYMBOL_BLACK_LISTED_EVENTS]) { 2441 Zone[SYMBOL_BLACK_LISTED_EVENTS] = Zone[SYMBOL_UNPATCHED_EVENTS] = 2442 global[SYMBOL_BLACK_LISTED_EVENTS]; 2443 } 2444 api.patchEventPrototype = patchEventPrototype; 2445 api.patchEventTarget = patchEventTarget; 2446 api.isIEOrEdge = isIEOrEdge; 2447 api.ObjectDefineProperty = ObjectDefineProperty; 2448 api.ObjectGetOwnPropertyDescriptor = ObjectGetOwnPropertyDescriptor; 2449 api.ObjectCreate = ObjectCreate; 2450 api.ArraySlice = ArraySlice; 2451 api.patchClass = patchClass; 2452 api.wrapWithCurrentZone = wrapWithCurrentZone; 2453 api.filterProperties = filterProperties; 2454 api.attachOriginToPatched = attachOriginToPatched; 2455 api._redefineProperty = Object.defineProperty; 2456 api.patchCallbacks = patchCallbacks; 2457 api.getGlobalObjects = function () { return ({ 2458 globalSources: globalSources, 2459 zoneSymbolEventNames: zoneSymbolEventNames, 2460 eventNames: eventNames, 2461 isBrowser: isBrowser, 2462 isMix: isMix, 2463 isNode: isNode, 2464 TRUE_STR: TRUE_STR, 2465 FALSE_STR: FALSE_STR, 2466 ZONE_SYMBOL_PREFIX: ZONE_SYMBOL_PREFIX, 2467 ADD_EVENT_LISTENER_STR: ADD_EVENT_LISTENER_STR, 2468 REMOVE_EVENT_LISTENER_STR: REMOVE_EVENT_LISTENER_STR 2469 }); }; 2470 }); 2471 /** 2472 * @license 2473 * Copyright Google LLC All Rights Reserved. 2474 * 2475 * Use of this source code is governed by an MIT-style license that can be 2476 * found in the LICENSE file at https://angular.io/license 2477 */ 2478 /* 2479 * This is necessary for Chrome and Chrome mobile, to enable 2480 * things like redefining `createdCallback` on an element. 2481 */ 2482 var zoneSymbol; 2483 var _defineProperty; 2484 var _getOwnPropertyDescriptor; 2485 var _create; 2486 var unconfigurablesKey; 2487 function propertyPatch() { 2488 zoneSymbol = Zone.__symbol__; 2489 _defineProperty = Object[zoneSymbol('defineProperty')] = Object.defineProperty; 2490 _getOwnPropertyDescriptor = Object[zoneSymbol('getOwnPropertyDescriptor')] = 2491 Object.getOwnPropertyDescriptor; 2492 _create = Object.create; 2493 unconfigurablesKey = zoneSymbol('unconfigurables'); 2494 Object.defineProperty = function (obj, prop, desc) { 2495 if (isUnconfigurable(obj, prop)) { 2496 throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj); 2497 } 2498 var originalConfigurableFlag = desc.configurable; 2499 if (prop !== 'prototype') { 2500 desc = rewriteDescriptor(obj, prop, desc); 2501 } 2502 return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag); 2503 }; 2504 Object.defineProperties = function (obj, props) { 2505 Object.keys(props).forEach(function (prop) { 2506 Object.defineProperty(obj, prop, props[prop]); 2507 }); 2508 for (var _i = 0, _b = Object.getOwnPropertySymbols(props); _i < _b.length; _i++) { 2509 var sym = _b[_i]; 2510 var desc = Object.getOwnPropertyDescriptor(props, sym); 2511 // Since `Object.getOwnPropertySymbols` returns *all* symbols, 2512 // including non-enumerable ones, retrieve property descriptor and check 2513 // enumerability there. Proceed with the rewrite only when a property is 2514 // enumerable to make the logic consistent with the way regular
2515 // properties are retrieved (via `Object.keys`, which respects 2516 // `enumerable: false` flag). More information: 2517 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties#retrieval 2518 if (desc === null || desc === void 0 ? void 0 : desc.enumerable) { 2519 Object.defineProperty(obj, sym, props[sym]); 2520 } 2521 } 2522 return obj; 2523 }; 2524 Object.create = function (proto, propertiesObject) { 2525 if (typeof propertiesObject === 'object' && !Object.isFrozen(propertiesObject)) { 2526 Object.keys(propertiesObject).forEach(function (prop) { 2527 propertiesObject[prop] = rewriteDescriptor(proto, prop, propertiesObject[prop]); 2528 }); 2529 } 2530 return _create(proto, propertiesObject); 2531 }; 2532 Object.getOwnPropertyDescriptor = function (obj, prop) { 2533 var desc = _getOwnPropertyDescriptor(obj, prop); 2534 if (desc && isUnconfigurable(obj, prop)) { 2535 desc.configurable = false; 2536 } 2537 return desc; 2538 }; 2539 } 2540 function _redefineProperty(obj, prop, desc) { 2541 var originalConfigurableFlag = desc.configurable; 2542 desc = rewriteDescriptor(obj, prop, desc); 2543 return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag); 2544 } 2545 function isUnconfigurable(obj, prop) { 2546 return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop]; 2547 } 2548 function rewriteDescriptor(obj, prop, desc) { 2549 // issue-927, if the desc is frozen, don't try to change the desc 2550 if (!Object.isFrozen(desc)) { 2551 desc.configurable = true; 2552 } 2553 if (!desc.configurable) { 2554 // issue-927, if the obj is frozen, don't try to set the desc to obj 2555 if (!obj[unconfigurablesKey] && !Object.isFrozen(obj)) { 2556 _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} }); 2557 } 2558 if (obj[unconfigurablesKey]) { 2559 obj[unconfigurablesKey][prop] = true; 2560 } 2561 } 2562 return desc; 2563 } 2564 function _tryDefineProperty(obj, prop, desc, originalConfigurableFlag) { 2565 try { 2566 return _defineProperty(obj, prop, desc); 2567 } 2568 catch (error) { 2569 if (desc.configurable) { 2570 // In case of errors, when the configurable flag was likely set by rewriteDescriptor(), 2571 // let's retry with the original flag value 2572 if (typeof originalConfigurableFlag == 'undefined') { 2573 delete desc.configurable; 2574 } 2575 else { 2576 desc.configurable = originalConfigurableFlag; 2577 } 2578 try { 2579 return _defineProperty(obj, prop, desc); 2580 } 2581 catch (error) { 2582 var swallowError = false; 2583 if (prop === 'createdCallback' || prop === 'attachedCallback' || 2584 prop === 'detachedCallback' || prop === 'attributeChangedCallback') { 2585 // We only swallow the error in registerElement patch 2586 // this is the work around since some applications 2587 // fail if we throw the error 2588 swallowError = true; 2589 } 2590 if (!swallowError) { 2591 throw error; 2592 } 2593 // TODO: @JiaLiPassion, Some application such as `registerElement` patch 2594 // still need to swallow the error, in the future after these applications 2595 // are updated, the following logic can be removed. 2596 var descJson = null; 2597 try { 2598 descJson = JSON.stringify(desc); 2599 } 2600 catch (error) { 2601 descJson = desc.toString(); 2602 } 2603 console.log("Attempting to configure '".concat(prop, "' with descriptor '").concat(descJson, "' on object '").concat(obj, "' and got error, giving up: ").concat(error)); 2604 } 2605 } 2606 else { 2607 throw error; 2608 } 2609 } 2610 } 2611 /** 2612 * @license 2613 * Copyright Google LLC All Rights Reserved. 2614 * 2615 * Use of this source code is governed by an MIT-style license that can be 2616 * found in the LICENSE file at https://angular.io/license 2617 */ 2618 function eventTargetLegacyPatch(_global, api) { 2619 var _b = api.getGlobalObjects(), eventNames = _b.eventNames, globalSources = _b.globalSources, zoneSymbolEventNames = _b.zoneSymbolEventNames, TRUE_STR = _b.TRUE_STR, FALSE_STR = _b.FALSE_STR, ZONE_SYMBOL_PREFIX = _b.ZONE_SYMBOL_PREFIX; 2620 var WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video'; 2621 var NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket' 2622 .split(','); 2623 var EVENT_TARGET = 'EventTarget'; 2624 var apis = []; 2625 var isWtf = _global['wtf']; 2626 var WTF_ISSUE_555_ARRAY = WTF_ISSUE_555.split(','); 2627 if (isWtf) { 2628 // Workaround for: https://github.com/google/tracing-framework/issues/555 2629 apis = WTF_ISSUE_555_ARRAY.map(function (v) { return 'HTML' + v + 'Element'; }).concat(NO_EVENT_TARGET); 2630 } 2631 else if (_global[EVENT_TARGET]) { 2632 apis.push(EVENT_TARGET); 2633 } 2634 else { 2635 // Note: EventTarget is not available in all browsers, 2636 // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget 2637 apis = NO_EVENT_TARGET; 2638 } 2639 var isDisableIECheck = _global['__Zone_disable_IE_check'] || false; 2640 var isEnableCrossContextCheck = _global['__Zone_enable_cross_context_check'] || false; 2641 var ieOrEdge = api.isIEOrEdge(); 2642 var ADD_EVENT_LISTENER_SOURCE = '.addEventListener:'; 2643 var FUNCTION_WRAPPER = '[object FunctionWrapper]'; 2644 var BROWSER_TOOLS = 'function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }'; 2645 var pointerEventsMap = { 2646 'MSPointerCancel': 'pointercancel', 2647 'MSPointerDown': 'pointerdown', 2648 'MSPointerEnter': 'pointerenter', 2649 'MSPointerHover': 'pointerhover', 2650 'MSPointerLeave': 'pointerleave', 2651 'MSPointerMove': 'pointermove', 2652 'MSPointerOut': 'pointerout', 2653 'MSPointerOver': 'pointerover', 2654 'MSPointerUp': 'pointerup' 2655 }; 2656 // predefine all __zone_symbol__ + eventName + true/false string 2657 for (var i = 0; i < eventNames.length; i++) { 2658 var eventName = eventNames[i]; 2659 var falseEventName = eventName + FALSE_STR; 2660 var trueEventName = eventName + TRUE_STR; 2661 var symbol = ZONE_SYMBOL_PREFIX + falseEventName; 2662 var symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName; 2663 zoneSymbolEventNames[eventName] = {}; 2664 zoneSymbolEventNames[eventName][FALSE_STR] = symbol; 2665 zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture; 2666 } 2667 // predefine all task.source string 2668 for (var i = 0; i < WTF_ISSUE_555_ARRAY.length; i++) { 2669 var target = WTF_ISSUE_555_ARRAY[i]; 2670 var targets = globalSources[target] = {}; 2671 for (var j = 0; j < eventNames.length; j++) { 2672 var eventName = eventNames[j]; 2673 targets[eventName] = target + ADD_EVENT_LISTENER_SOURCE + eventName; 2674 } 2675 } 2676 var checkIEAndCrossContext = function (nativeDelegate, delegate, target, args) { 2677 if (!isDisableIECheck && ieOrEdge) { 2678 if (isEnableCrossContextCheck) { 2679 try { 2680 var testString = delegate.toString(); 2681 if ((testString === FUNCTION_WRAPPER || testString == BROWSER_TOOLS)) { 2682 nativeDelegate.apply(target, args); 2683 return false;
2684 } 2685 } 2686 catch (error) { 2687 nativeDelegate.apply(target, args); 2688 return false; 2689 } 2690 } 2691 else { 2692 var testString = delegate.toString(); 2693 if ((testString === FUNCTION_WRAPPER || testString == BROWSER_TOOLS)) { 2694 nativeDelegate.apply(target, args); 2695 return false; 2696 } 2697 } 2698 } 2699 else if (isEnableCrossContextCheck) { 2700 try { 2701 delegate.toString(); 2702 } 2703 catch (error) { 2704 nativeDelegate.apply(target, args); 2705 return false; 2706 } 2707 } 2708 return true; 2709 }; 2710 var apiTypes = []; 2711 for (var i = 0; i < apis.length; i++) { 2712 var type = _global[apis[i]]; 2713 apiTypes.push(type && type.prototype); 2714 } 2715 // vh is validateHandler to check event handler 2716 // is valid or not(for security check) 2717 api.patchEventTarget(_global, api, apiTypes, { 2718 vh: checkIEAndCrossContext, 2719 transferEventName: function (eventName) { 2720 var pointerEventName = pointerEventsMap[eventName]; 2721 return pointerEventName || eventName; 2722 } 2723 }); 2724 Zone[api.symbol('patchEventTarget')] = !!_global[EVENT_TARGET]; 2725 return true; 2726 } 2727 /** 2728 * @license 2729 * Copyright Google LLC All Rights Reserved. 2730 * 2731 * Use of this source code is governed by an MIT-style license that can be 2732 * found in the LICENSE file at https://angular.io/license 2733 */ 2734 // we have to patch the instance since the proto is non-configurable 2735 function apply(api, _global) { 2736 var _b = api.getGlobalObjects(), ADD_EVENT_LISTENER_STR = _b.ADD_EVENT_LISTENER_STR, REMOVE_EVENT_LISTENER_STR = _b.REMOVE_EVENT_LISTENER_STR; 2737 var WS = _global.WebSocket; 2738 // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener 2739 // On older Chrome, no need since EventTarget was already patched 2740 if (!_global.EventTarget) { 2741 api.patchEventTarget(_global, api, [WS.prototype]); 2742 } 2743 _global.WebSocket = function (x, y) { 2744 var socket = arguments.length > 1 ? new WS(x, y) : new WS(x); 2745 var proxySocket; 2746 var proxySocketProto; 2747 // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance 2748 var onmessageDesc = api.ObjectGetOwnPropertyDescriptor(socket, 'onmessage'); 2749 if (onmessageDesc && onmessageDesc.configurable === false) { 2750 proxySocket = api.ObjectCreate(socket); 2751 // socket have own property descriptor 'onopen', 'onmessage', 'onclose', 'onerror' 2752 // but proxySocket not, so we will keep socket as prototype and pass it to 2753 // patchOnProperties method 2754 proxySocketProto = socket; 2755 [ADD_EVENT_LISTENER_STR, REMOVE_EVENT_LISTENER_STR, 'send', 'close'].forEach(function (propName) { 2756 proxySocket[propName] = function () { 2757 var args = api.ArraySlice.call(arguments); 2758 if (propName === ADD_EVENT_LISTENER_STR || propName === REMOVE_EVENT_LISTENER_STR) { 2759 var eventName = args.length > 0 ? args[0] : undefined; 2760 if (eventName) { 2761 var propertySymbol = Zone.__symbol__('ON_PROPERTY' + eventName); 2762 socket[propertySymbol] = proxySocket[propertySymbol]; 2763 } 2764 } 2765 return socket[propName].apply(socket, args); 2766 }; 2767 }); 2768 } 2769 else { 2770 // we can patch the real socket 2771 proxySocket = socket; 2772 } 2773 api.patchOnProperties(proxySocket, ['close', 'error', 'message', 'open'], proxySocketProto); 2774 return proxySocket; 2775 }; 2776 var globalWebSocket = _global['WebSocket']; 2777 for (var prop in WS) { 2778 globalWebSocket[prop] = WS[prop]; 2779 } 2780 } 2781 /** 2782 * @license 2783 * Copyright Google LLC All Rights Reserved. 2784 * 2785 * Use of this source code is governed by an MIT-style license that can be 2786 * found in the LICENSE file at https://angular.io/license 2787 */ 2788 function propertyDescriptorLegacyPatch(api, _global) { 2789 var _b = api.getGlobalObjects(), isNode = _b.isNode, isMix = _b.isMix; 2790 if (isNode && !isMix) { 2791 return; 2792 }
2793 if (!canPatchViaPropertyDescriptor(api, _global)) { 2794 var supportsWebSocket = typeof WebSocket !== 'undefined'; 2795 // Safari, Android browsers (Jelly Bean) 2796 patchViaCapturingAllTheEvents(api); 2797 api.patchClass('XMLHttpRequest'); 2798 if (supportsWebSocket) { 2799 apply(api, _global); 2800 } 2801 Zone[api.symbol('patchEvents')] = true; 2802 } 2803 } 2804 function canPatchViaPropertyDescriptor(api, _global) { 2805 var _b = api.getGlobalObjects(), isBrowser = _b.isBrowser, isMix = _b.isMix; 2806 if ((isBrowser || isMix) && 2807 !api.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') && 2808 typeof Element !== 'undefined') { 2809 // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364 2810 // IDL interface attributes are not configurable 2811 var desc = api.ObjectGetOwnPropertyDescriptor(Element.prototype, 'onclick'); 2812 if (desc && !desc.configurable) 2813 return false; 2814 // try to use onclick to detect whether we can patch via propertyDescriptor 2815 // because XMLHttpRequest is not available in service worker 2816 if (desc) { 2817 api.ObjectDefineProperty(Element.prototype, 'onclick', { 2818 enumerable: true, 2819 configurable: true, 2820 get: function () { 2821 return true; 2822 } 2823 }); 2824 var div = document.createElement('div'); 2825 var result = !!div.onclick; 2826 api.ObjectDefineProperty(Element.prototype, 'onclick', desc); 2827 return result; 2828 } 2829 } 2830 var XMLHttpRequest = _global['XMLHttpRequest']; 2831 if (!XMLHttpRequest) { 2832 // XMLHttpRequest is not available in service worker 2833 return false; 2834 } 2835 var ON_READY_STATE_CHANGE = 'onreadystatechange'; 2836 var XMLHttpRequestPrototype = XMLHttpRequest.prototype; 2837 var xhrDesc = api.ObjectGetOwnPropertyDescriptor(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE); 2838 // add enumerable and configurable here because in opera 2839 // by default XMLHttpRequest.prototype.onreadystatechange is undefined 2840 // without adding enumerable and configurable will cause onreadystatechange 2841 // non-configurable 2842 // and if XMLHttpRequest.prototype.onreadystatechange is undefined, 2843 // we should set a real desc instead a fake one 2844 if (xhrDesc) { 2845 api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, { 2846 enumerable: true, 2847 configurable: true, 2848 get: function () { 2849 return true; 2850 } 2851 }); 2852 var req = new XMLHttpRequest(); 2853 var result = !!req.onreadystatechange; 2854 // restore original desc 2855 api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, xhrDesc || {}); 2856 return result; 2857 } 2858 else { 2859 var SYMBOL_FAKE_ONREADYSTATECHANGE_1 = api.symbol('fake'); 2860 api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, { 2861 enumerable: true, 2862 configurable: true, 2863 get: function () { 2864 return this[SYMBOL_FAKE_ONREADYSTATECHANGE_1]; 2865 }, 2866 set: function (value) { 2867 this[SYMBOL_FAKE_ONREADYSTATECHANGE_1] = value; 2868 } 2869 }); 2870 var req = new XMLHttpRequest(); 2871 var detectFunc = function () { }; 2872 req.onreadystatechange = detectFunc; 2873 var result = req[SYMBOL_FAKE_ONREADYSTATECHANGE_1] === detectFunc; 2874 req.onreadystatechange = null; 2875 return result; 2876 } 2877 } 2878 var globalEventHandlersEventNames = [ 2879 'abort', 2880 'animationcancel', 2881 'animationend', 2882 'animationiteration', 2883 'auxclick', 2884 'beforeinput', 2885 'blur', 2886 'cancel', 2887 'canplay', 2888 'canplaythrough', 2889 'change', 2890 'compositionstart', 2891 'compositionupdate', 2892 'compositionend', 2893 'cuechange', 2894 'click', 2895 'close', 2896 'contextmenu', 2897 'curechange', 2898 'dblclick', 2899 'drag', 2900 'dragend', 2901 'dragenter', 2902 'dragexit', 2903 'dragleave', 2904 'dragover', 2905 'drop', 2906 'durationchange', 2907 'emptied', 2908 'ended', 2909 'error',
2910 'focus', 2911 'focusin', 2912 'focusout', 2913 'gotpointercapture', 2914 'input', 2915 'invalid', 2916 'keydown', 2917 'keypress', 2918 'keyup', 2919 'load', 2920 'loadstart', 2921 'loadeddata', 2922 'loadedmetadata', 2923 'lostpointercapture', 2924 'mousedown', 2925 'mouseenter', 2926 'mouseleave', 2927 'mousemove', 2928 'mouseout', 2929 'mouseover', 2930 'mouseup', 2931 'mousewheel', 2932 'orientationchange', 2933 'pause', 2934 'play', 2935 'playing', 2936 'pointercancel', 2937 'pointerdown', 2938 'pointerenter', 2939 'pointerleave', 2940 'pointerlockchange', 2941 'mozpointerlockchange', 2942 'webkitpointerlockerchange', 2943 'pointerlockerror', 2944 'mozpointerlockerror', 2945 'webkitpointerlockerror', 2946 'pointermove', 2947 'pointout', 2948 'pointerover', 2949 'pointerup', 2950 'progress', 2951 'ratechange', 2952 'reset', 2953 'resize', 2954 'scroll', 2955 'seeked', 2956 'seeking', 2957 'select', 2958 'selectionchange', 2959 'selectstart', 2960 'show', 2961 'sort', 2962 'stalled', 2963 'submit', 2964 'suspend', 2965 'timeupdate', 2966 'volumechange', 2967 'touchcancel', 2968 'touchmove', 2969 'touchstart', 2970 'touchend', 2971 'transitioncancel', 2972 'transitionend', 2973 'waiting', 2974 'wheel' 2975 ]; 2976 var documentEventNames = [ 2977 'afterscriptexecute', 'beforescriptexecute', 'DOMContentLoaded', 'freeze', 'fullscreenchange', 2978 'mozfullscreenchange', 'webkitfullscreenchange', 'msfullscreenchange', 'fullscreenerror', 2979 'mozfullscreenerror', 'webkitfullscreenerror', 'msfullscreenerror', 'readystatechange', 2980 'visibilitychange', 'resume' 2981 ]; 2982 var windowEventNames = [ 2983 'absolutedeviceorientation', 2984 'afterinput', 2985 'afterprint', 2986 'appinstalled', 2987 'beforeinstallprompt', 2988 'beforeprint', 2989 'beforeunload', 2990 'devicelight', 2991 'devicemotion', 2992 'deviceorientation', 2993 'deviceorientationabsolute', 2994 'deviceproximity', 2995 'hashchange', 2996 'languagechange', 2997 'message', 2998 'mozbeforepaint', 2999 'offline', 3000 'online', 3001 'paint', 3002 'pageshow', 3003 'pagehide', 3004 'popstate', 3005 'rejectionhandled', 3006 'storage', 3007 'unhandledrejection', 3008 'unload', 3009 'userproximity', 3010 'vrdisplayconnected', 3011 'vrdisplaydisconnected', 3012 'vrdisplaypresentchange' 3013 ]; 3014 var htmlElementEventNames = [ 3015 'beforecopy', 'beforecut', 'beforepaste', 'copy', 'cut', 'paste', 'dragstart', 'loadend', 3016 'animationstart', 'search', 'transitionrun', 'transitionstart', 'webkitanimationend', 3017 'webkitanimationiteration', 'webkitanimationstart', 'webkittransitionend' 3018 ]; 3019 var ieElementEventNames = [ 3020 'activate', 3021 'afterupdate', 3022 'ariarequest', 3023 'beforeactivate', 3024 'beforedeactivate', 3025 'beforeeditfocus', 3026 'beforeupdate', 3027 'cellchange', 3028 'controlselect', 3029 'dataavailable', 3030 'datasetchanged', 3031 'datasetcomplete', 3032 'errorupdate', 3033 'filterchange', 3034 'layoutcomplete', 3035 'losecapture', 3036 'move', 3037 'moveend', 3038 'movestart', 3039 'propertychange', 3040 'resizeend', 3041 'resizestart', 3042 'rowenter', 3043 'rowexit', 3044 'rowsdelete', 3045 'rowsinserted', 3046 'command', 3047 'compassneedscalibration', 3048 'deactivate', 3049 'help', 3050 'mscontentzoom', 3051 'msmanipulationstatechanged', 3052 'msgesturechange', 3053 'msgesturedoubletap', 3054 'msgestureend', 3055 'msgesturehold', 3056 'msgesturestart', 3057 'msgesturetap', 3058 'msgotpointercapture', 3059 'msinertiastart', 3060 'mslostpointercapture', 3061 'mspointercancel', 3062 'mspointerdown', 3063 'mspointerenter', 3064 'mspointerhover', 3065 'mspointerleave', 3066 'mspointermove', 3067 'mspointerout', 3068 'mspointerover', 3069 'mspointerup', 3070 'pointerout', 3071 'mssitemodejumplistitemremoved', 3072 'msthumbnailclick', 3073 'stop', 3074 'storagecommit' 3075 ];
3076 var webglEventNames = ['webglcontextrestored', 'webglcontextlost', 'webglcontextcreationerror']; 3077 var formEventNames = ['autocomplete', 'autocompleteerror']; 3078 var detailEventNames = ['toggle']; 3079 var eventNames = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], globalEventHandlersEventNames, true), webglEventNames, true), formEventNames, true), detailEventNames, true), documentEventNames, true), windowEventNames, true), htmlElementEventNames, true), ieElementEventNames, true); 3080 // Whenever any eventListener fires, we check the eventListener target and all parents 3081 // for `onwhatever` properties and replace them with zone-bound functions 3082 // - Chrome (for now) 3083 function patchViaCapturingAllTheEvents(api) { 3084 var unboundKey = api.symbol('unbound'); 3085 var _loop_5 = function (i) { 3086 var property = eventNames[i]; 3087 var onproperty = 'on' + property; 3088 self.addEventListener(property, function (event) { 3089 var elt = event.target, bound, source; 3090 if (elt) { 3091 source = elt.constructor['name'] + '.' + onproperty; 3092 } 3093 else { 3094 source = 'unknown.' + onproperty; 3095 } 3096 while (elt) { 3097 if (elt[onproperty] && !elt[onproperty][unboundKey]) { 3098 bound = api.wrapWithCurrentZone(elt[onproperty], source); 3099 bound[unboundKey] = elt[onproperty]; 3100 elt[onproperty] = bound; 3101 } 3102 elt = elt.parentElement; 3103 } 3104 }, true); 3105 }; 3106 for (var i = 0; i < eventNames.length; i++) { 3107 _loop_5(i); 3108 } 3109 } 3110 /** 3111 * @license 3112 * Copyright Google LLC All Rights Reserved. 3113 * 3114 * Use of this source code is governed by an MIT-style license that can be 3115 * found in the LICENSE file at https://angular.io/license 3116 */ 3117 function registerElementPatch(_global, api) { 3118 var _b = api.getGlobalObjects(), isBrowser = _b.isBrowser, isMix = _b.isMix; 3119 if ((!isBrowser && !isMix) || !('registerElement' in _global.document)) { 3120 return; 3121 } 3122 var callbacks = ['createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback']; 3123 api.patchCallbacks(api, document, 'Document', 'registerElement', callbacks); 3124 } 3125 /** 3126 * @license 3127 * Copyright Google LLC All Rights Reserved. 3128 * 3129 * Use of this source code is governed by an MIT-style license that can be 3130 * found in the LICENSE file at https://angular.io/license 3131 */ 3132 (function (_global) { 3133 var symbolPrefix = _global['__Zone_symbol_prefix'] || '__zone_symbol__'; 3134 function __symbol__(name) { 3135 return symbolPrefix + name; 3136 } 3137 _global[__symbol__('legacyPatch')] = function () { 3138 var Zone = _global['Zone']; 3139 Zone.__load_patch('defineProperty', function (global, Zone, api) { 3140 api._redefineProperty = _redefineProperty; 3141 propertyPatch(); 3142 }); 3143 Zone.__load_patch('registerElement', function (global, Zone, api) { 3144 registerElementPatch(global, api); 3145 }); 3146 Zone.__load_patch('EventTargetLegacy', function (global, Zone, api) { 3147 eventTargetLegacyPatch(global, api); 3148 propertyDescriptorLegacyPatch(api, global); 3149 }); 3150 }; 3151 })(typeof window !== 'undefined' ? 3152 window : 3153 typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}); 3154 /** 3155 * @license 3156 * Copyright Google LLC All Rights Reserved. 3157 * 3158 * Use of this source code is governed by an MIT-style license that can be 3159 * found in the LICENSE file at https://angular.io/license 3160 */ 3161 var taskSymbol = zoneSymbol$1('zoneTask'); 3162 function patchTimer(window, setName, cancelName, nameSuffix) { 3163 var setNative = null; 3164 var clearNative = null; 3165 setName += nameSuffix; 3166 cancelName += nameSuffix; 3167 var tasksByHandleId = {}; 3168 function scheduleTask(task) { 3169 var data = task.data; 3170 data.args[0] = function () { 3171 return task.invoke.apply(this, arguments); 3172 };
3173 data.handleId = setNative.apply(window, data.args); 3174 return task; 3175 } 3176 function clearTask(task) { 3177 return clearNative.call(window, task.data.handleId); 3178 } 3179 setNative = 3180 patchMethod(window, setName, function (delegate) { return function (self, args) { 3181 if (typeof args[0] === 'function') { 3182 var options_1 = { 3183 isPeriodic: nameSuffix === 'Interval', 3184 delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : 3185 undefined, 3186 args: args 3187 }; 3188 var callback_1 = args[0]; 3189 args[0] = function timer() { 3190 try { 3191 return callback_1.apply(this, arguments); 3192 } 3193 finally { 3194 // issue-934, task will be cancelled 3195 // even it is a periodic task such as 3196 // setInterval 3197 // https://github.com/angular/angular/issues/40387 3198 // Cleanup tasksByHandleId should be handled before scheduleTask 3199 // Since some zoneSpec may intercept and doesn't trigger 3200 // scheduleFn(scheduleTask) provided here. 3201 if (!(options_1.isPeriodic)) { 3202 if (typeof options_1.handleId === 'number') { 3203 // in non-nodejs env, we remove timerId 3204 // from local cache 3205 delete tasksByHandleId[options_1.handleId]; 3206 } 3207 else if (options_1.handleId) { 3208 // Node returns complex objects as handleIds 3209 // we remove task reference from timer object 3210 options_1.handleId[taskSymbol] = null; 3211 } 3212 } 3213 } 3214 }; 3215 var task = scheduleMacroTaskWithCurrentZone(setName, args[0], options_1, scheduleTask, clearTask); 3216 if (!task) { 3217 return task; 3218 } 3219 // Node.js must additionally support the ref and unref functions. 3220 var handle = task.data.handleId; 3221 if (typeof handle === 'number') { 3222 // for non nodejs env, we save handleId: task 3223 // mapping in local cache for clearTimeout 3224 tasksByHandleId[handle] = task; 3225 } 3226 else if (handle) { 3227 // for nodejs env, we save task 3228 // reference in timerId Object for clearTimeout 3229 handle[taskSymbol] = task; 3230 } 3231 // check whether handle is null, because some polyfill or browser 3232 // may return undefined from setTimeout/setInterval/setImmediate/requestAnimationFrame 3233 if (handle && handle.ref && handle.unref && typeof handle.ref === 'function' && 3234 typeof handle.unref === 'function') { 3235 task.ref = handle.ref.bind(handle); 3236 task.unref = handle.unref.bind(handle); 3237 } 3238 if (typeof handle === 'number' || handle) { 3239 return handle; 3240 } 3241 return task; 3242 } 3243 else { 3244 // cause an error by calling it directly. 3245 return delegate.apply(window, args); 3246 } 3247 }; }); 3248 clearNative = 3249 patchMethod(window, cancelName, function (delegate) { return function (self, args) { 3250 var id = args[0]; 3251 var task; 3252 if (typeof id === 'number') { 3253 // non nodejs env. 3254 task = tasksByHandleId[id]; 3255 } 3256 else { 3257 // nodejs env. 3258 task = id && id[taskSymbol]; 3259 // other environments. 3260 if (!task) { 3261 task = id; 3262 } 3263 } 3264 if (task && typeof task.type === 'string') { 3265 if (task.state !== 'notScheduled' && 3266 (task.cancelFn && task.data.isPeriodic || task.runCount === 0)) { 3267 if (typeof id === 'number') { 3268 delete tasksByHandleId[id]; 3269 } 3270 else if (id) { 3271 id[taskSymbol] = null; 3272 }
3273 // Do not cancel already canceled functions 3274 task.zone.cancelTask(task); 3275 } 3276 } 3277 else { 3278 // cause an error by calling it directly. 3279 delegate.apply(window, args); 3280 } 3281 }; }); 3282 } 3283 /** 3284 * @license 3285 * Copyright Google LLC All Rights Reserved. 3286 * 3287 * Use of this source code is governed by an MIT-style license that can be 3288 * found in the LICENSE file at https://angular.io/license 3289 */ 3290 function patchCustomElements(_global, api) { 3291 var _b = api.getGlobalObjects(), isBrowser = _b.isBrowser, isMix = _b.isMix; 3292 if ((!isBrowser && !isMix) || !_global['customElements'] || !('customElements' in _global)) { 3293 return; 3294 } 3295 var callbacks = ['connectedCallback', 'disconnectedCallback', 'adoptedCallback', 'attributeChangedCallback']; 3296 api.patchCallbacks(api, _global.customElements, 'customElements', 'define', callbacks); 3297 } 3298 /** 3299 * @license 3300 * Copyright Google LLC All Rights Reserved. 3301 * 3302 * Use of this source code is governed by an MIT-style license that can be 3303 * found in the LICENSE file at https://angular.io/license 3304 */ 3305 function eventTargetPatch(_global, api) { 3306 if (Zone[api.symbol('patchEventTarget')]) { 3307 // EventTarget is already patched. 3308 return; 3309 } 3310 var _b = api.getGlobalObjects(), eventNames = _b.eventNames, zoneSymbolEventNames = _b.zoneSymbolEventNames, TRUE_STR = _b.TRUE_STR, FALSE_STR = _b.FALSE_STR, ZONE_SYMBOL_PREFIX = _b.ZONE_SYMBOL_PREFIX; 3311 // predefine all __zone_symbol__ + eventName + true/false string 3312 for (var i = 0; i < eventNames.length; i++) { 3313 var eventName = eventNames[i]; 3314 var falseEventName = eventName + FALSE_STR; 3315 var trueEventName = eventName + TRUE_STR; 3316 var symbol = ZONE_SYMBOL_PREFIX + falseEventName; 3317 var symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName; 3318 zoneSymbolEventNames[eventName] = {}; 3319 zoneSymbolEventNames[eventName][FALSE_STR] = symbol; 3320 zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture; 3321 } 3322 var EVENT_TARGET = _global['EventTarget']; 3323 if (!EVENT_TARGET || !EVENT_TARGET.prototype) { 3324 return; 3325 } 3326 api.patchEventTarget(_global, api, [EVENT_TARGET && EVENT_TARGET.prototype]); 3327 return true; 3328 } 3329 function patchEvent(global, api) { 3330 api.patchEventPrototype(global, api); 3331 } 3332 /** 3333 * @license 3334 * Copyright Google LLC All Rights Reserved. 3335 * 3336 * Use of this source code is governed by an MIT-style license that can be 3337 * found in the LICENSE file at https://angular.io/license 3338 */ 3339 Zone.__load_patch('legacy', function (global) { 3340 var legacyPatch = global[Zone.__symbol__('legacyPatch')]; 3341 if (legacyPatch) { 3342 legacyPatch(); 3343 } 3344 }); 3345 Zone.__load_patch('queueMicrotask', function (global, Zone, api) { 3346 api.patchMethod(global, 'queueMicrotask', function (delegate) { 3347 return function (self, args) { 3348 Zone.current.scheduleMicroTask('queueMicrotask', args[0]); 3349 }; 3350 }); 3351 }); 3352 Zone.__load_patch('timers', function (global) { 3353 var set = 'set'; 3354 var clear = 'clear'; 3355 patchTimer(global, set, clear, 'Timeout'); 3356 patchTimer(global, set, clear, 'Interval'); 3357 patchTimer(global, set, clear, 'Immediate'); 3358 }); 3359 Zone.__load_patch('requestAnimationFrame', function (global) { 3360 patchTimer(global, 'request', 'cancel', 'AnimationFrame'); 3361 patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame'); 3362 patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame'); 3363 }); 3364 Zone.__load_patch('blocking', function (global, Zone) { 3365 var blockingMethods = ['alert', 'prompt', 'confirm']; 3366 for (var i = 0; i < blockingMethods.length; i++) { 3367 var name_2 = blockingMethods[i]; 3368 patchMethod(global, name_2, function (delegate, symbol, name) { 3369 return function (s, args) { 3370 return Zone.current.run(delegate, global, args, name); 3371 }; 3372 }); 3373 } 3374 }); 3375 Zone.__load_patch('EventTarget', function (global, Zone, api) { 3376 patchEvent(global, api); 3377 eventTargetPatch(global, api); 3378 // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener 3379 var XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget']; 3380 if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) { 3381 api.patchEventTarget(global, api, [XMLHttpRequestEventTarget.prototype]); 3382 } 3383 }); 3384 Zone.__load_patch('MutationObserver', function (global, Zone, api) { 3385 patchClass('MutationObserver'); 3386 patchClass('WebKitMutationObserver'); 3387 }); 3388 Zone.__load_patch('IntersectionObserver', function (global, Zone, api) { 3389 patchClass('IntersectionObserver'); 3390 }); 3391 Zone.__load_patch('FileReader', function (global, Zone, api) { 3392 patchClass('FileReader'); 3393 }); 3394 Zone.__load_patch('on_property', function (global, Zone, api) { 3395 propertyDescriptorPatch(api, global); 3396 }); 3397 Zone.__load_patch('customElements', function (global, Zone, api) { 3398 patchCustomElements(global, api); 3399 }); 3400 Zone.__load_patch('XHR', function (global, Zone) { 3401 // Treat XMLHttpRequest as a macrotask. 3402 patchXHR(global); 3403 var XHR_TASK = zoneSymbol$1('xhrTask'); 3404 var XHR_SYNC = zoneSymbol$1('xhrSync'); 3405 var XHR_LISTENER = zoneSymbol$1('xhrListener'); 3406 var XHR_SCHEDULED = zoneSymbol$1('xhrScheduled'); 3407 var XHR_URL = zoneSymbol$1('xhrURL'); 3408 var XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol$1('xhrErrorBeforeScheduled'); 3409 function patchXHR(window) { 3410 var XMLHttpRequest = window['XMLHttpRequest']; 3411 if (!XMLHttpRequest) { 3412 // XMLHttpRequest is not available in service worker 3413 return; 3414 } 3415 var XMLHttpRequestPrototype = XMLHttpRequest.prototype; 3416 function findPendingTask(target) { 3417 return target[XHR_TASK]; 3418 } 3419 var oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER]; 3420 var oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_
3420EVENT_LISTENER]; 3421 if (!oriAddListener) { 3422 var XMLHttpRequestEventTarget_1 = window['XMLHttpRequestEventTarget']; 3423 if (XMLHttpRequestEventTarget_1) { 3424 var XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget_1.prototype; 3425 oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER]; 3426 oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER]; 3427 } 3428 } 3429 var READY_STATE_CHANGE = 'readystatechange'; 3430 var SCHEDULED = 'scheduled'; 3431 function scheduleTask(task) { 3432 var data = task.data; 3433 var target = data.target; 3434 target[XHR_SCHEDULED] = false; 3435 target[XHR_ERROR_BEFORE_SCHEDULED] = false; 3436 // remove existing event listener 3437 var listener = target[XHR_LISTENER]; 3438 if (!oriAddListener) { 3439 oriAddListener = target[ZONE_SYMBOL_ADD_EVENT_LISTENER]; 3440 oriRemoveListener = target[ZONE_SYMBOL_REMOVE_
3440EVENT_LISTENER]; 3441 } 3442 if (listener) { 3443 oriRemoveListener.call(target, READY_STATE_CHANGE, listener); 3444 } 3445 var newListener = target[XHR_LISTENER] = function () { 3446 if (target.readyState === target.DONE) { 3447 // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with 3448 // readyState=4 multiple times, so we need to check task state here 3449 if (!data.aborted && target[XHR_SCHEDULED] && task.state === SCHEDULED) { 3450 // check whether the xhr has registered onload listener 3451 // if that is the case, the task should invoke after all 3452 // onload listeners finish. 3453 // Also if the request failed without response (status = 0), the load event handler 3454 // will not be triggered, in that case, we should also invoke the placeholder callback 3455 // to close the XMLHttpRequest::send macroTask. 3456 // https://github.com/angular/angular/issues/38795 3457 var loadTasks = target[Zone.__symbol__('loadfalse')]; 3458 if (target.status !== 0 && loadTasks && loadTasks.length > 0) { 3459 var oriInvoke_1 = task.invoke; 3460 task.invoke = function () { 3461 // need to load the tasks again, because in other 3462 // load listener, they may remove themselves 3463 var loadTasks = target[Zone.__symbol__('loadfalse')]; 3464 for (var i = 0; i < loadTasks.length; i++) { 3465 if (loadTasks[i] === task) { 3466 loadTasks.splice(i, 1); 3467 } 3468 } 3469 if (!data.aborted && task.state === SCHEDULED) { 3470 oriInvoke_1.call(task); 3471 } 3472 }; 3473 loadTasks.push(task); 3474 } 3475 else { 3476 task.invoke(); 3477 } 3478 } 3479 else if (!data.aborted && target[XHR_SCHEDULED] === false) { 3480 // error occurs when xhr.send() 3481 target[XHR_ERROR_BEFORE_SCHEDULED] = true; 3482 } 3483 } 3484 }; 3485 oriAddListener.call(target, READY_STATE_CHANGE, newListener); 3486 var storedTask = target[XHR_TASK]; 3487 if (!storedTask) { 3488 target[XHR_TASK] = task; 3489 }
3490 sendNative.apply(target, data.args); 3491 target[XHR_SCHEDULED] = true; 3492 return task; 3493 } 3494 function placeholderCallback() { } 3495 function clearTask(task) { 3496 var data = task.data; 3497 // Note - ideally, we would call data.target.removeEventListener here, but it's too late 3498 // to prevent it from firing. So instead, we store info for the event listener. 3499 data.aborted = true; 3500 return abortNative.apply(data.target, data.args); 3501 } 3502 var openNative = patchMethod(XMLHttpRequestPrototype, 'open', function () { return function (self, args) { 3503 self[XHR_SYNC] = args[2] == false; 3504 self[XHR_URL] = args[1]; 3505 return openNative.apply(self, args); 3506 }; }); 3507 var XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send'; 3508 var fetchTaskAborting = zoneSymbol$1('fetchTaskAborting'); 3509 var fetchTaskScheduling = zoneSymbol$1('fetchTaskScheduling'); 3510 var sendNative = patchMethod(XMLHttpRequestPrototype, 'send', function () { return function (self, args) { 3511 if (Zone.current[fetchTaskScheduling] === true) { 3512 // a fetch is scheduling, so we are using xhr to polyfill fetch 3513 // and because we already schedule macroTask for fetch, we should 3514 // not schedule a macroTask for xhr again 3515 return sendNative.apply(self, args); 3516 } 3517 if (self[XHR_SYNC]) { 3518 // if the XHR is sync there is no task to schedule, just execute the code. 3519 return sendNative.apply(self, args); 3520 } 3521 else { 3522 var options = { target: self, url: self[XHR_URL], isPeriodic: false, args: args, aborted: false }; 3523 var task = scheduleMacroTaskWithCurrentZone(XMLHTTPREQUEST_SOURCE, placeholderCallback, options, scheduleTask, clearTask); 3524 if (self && self[XHR_ERROR_BEFORE_SCHEDULED] === true && !options.aborted && 3525 task.state === SCHEDULED) { 3526 // xhr request throw error when send 3527 // we should invoke task instead of leaving a scheduled 3528 // pending macroTask 3529 task.invoke(); 3530 } 3531 } 3532 }; }); 3533 var abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', function () { return function (self, args) { 3534 var task = findPendingTask(self); 3535 if (task && typeof task.type == 'string') { 3536 // If the XHR has already completed, do nothing. 3537 // If the XHR has already been aborted, do nothing. 3538 // Fix #569, call abort multiple times before done will cause 3539 // macroTask task count be negative number 3540 if (task.cancelFn == null || (task.data && task.data.aborted)) { 3541 return; 3542 } 3543 task.zone.cancelTask(task); 3544 } 3545 else if (Zone.current[fetchTaskAborting] === true) { 3546 // the abort is called from fetch polyfill, we need to call native abort of XHR. 3547 return abortNative.apply(self, args); 3548 } 3549 // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no 3550 // task 3551 // to cancel. Do nothing. 3552 }; }); 3553 } 3554 }); 3555 Zone.__load_patch('geolocation', function (global) { 3556 /// GEO_LOCATION 3557 if (global['navigator'] && global['navigator'].geolocation) { 3558 patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']); 3559 } 3560 }); 3561 Zone.__load_patch('PromiseRejectionEvent', function (global, Zone) { 3562 // handle unhandled promise rejection 3563 function findPromiseRejectionHandler(evtName) { 3564 return function (e) { 3565 var eventTasks = findEventTasks(global, evtName); 3566 eventTasks.forEach(function (eventTask) { 3567 // windows has added unhandledrejection event listener 3568 // trigger the event listener 3569 var PromiseRejectionEvent = global['PromiseRejectionEvent']; 3570 if (PromiseRejectionEvent) { 3571 var evt = new PromiseRejectionEvent(evtName, { promise: e.promise, reason: e.rejection }); 3572 eventTask.invoke(evt); 3573 } 3574 }); 3575 }; 3576 } 3577 if (global['PromiseRejectionEvent']) { 3578 Zone[zoneSymbol$1('unhandledPromiseRejectionHandler')] = 3579 findPromiseRejectionHandler('unhandledrejection'); 3580 Zone[zoneSymbol$1('rejectionHandledHandler')] = 3581 findPromiseRejectionHandler('rejectionhandled'); 3582 } 3583 }); 3584})); 3585 3586 3587/***/ }), 3588 3589/***/ 7435: 3590/*!**************************!*\ 3591 !*** ./src/polyfills.ts ***! 3592 \**************************/ 3593/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 3594 3595"use strict"; 3596__webpack_require__.r(__webpack_exports__); 3597/* harmony import */ var _zone_flags__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./zone-flags */ 28270); 3598/* harmony import */ var _zone_flags__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_zone_flags__WEBPACK_IMPORTED_MODULE_0__); 3599/* harmony import */ var zone_js_dist_zone__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! zone.js/dist/zone */ 99140); 3600/* harmony import */ var zone_js_dist_zone__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(zone_js_dist_zone__WEBPACK_IMPORTED_MODULE_1__); 3601/** 3602 * This file includes polyfills needed by Angular and is loaded before the app. 3603 * You can add your own extra polyfills to this file. 3604 * 3605 * This file is divided into 2 sections: 3606 * 1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers. 3607 * 2. Application imports. Files imported after ZoneJS that should be loaded before your main 3608 * file. 3609 * 3610 * The current setup is for so-called "evergreen" browsers; the last versions of browsers that 3611 * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera), 3612 * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile. 3613 * 3614 * Learn more in https://angular.io/guide/browser-support 3615 */ 3616/*************************************************************************************************** 3617 * BROWSER POLYFILLS 3618 */ 3619/** IE11 requires the following for NgClass support on SVG elements */ 3620// import 'classlist.js'; // Run `npm install --save classlist.js`. 3621/** 3622 * Web Animations `@angular/platform-browser/animations` 3623 * Only required if AnimationBuilder is used within the application and using IE/Edge or Safari. 3624 * Standard animation support in Angular DOES NOT require any polyfills (as of Angular 6.0). 3625 */ 3626// import 'web-animations-js'; // Run `npm install --save web-animations-js`. 3627/** 3628 * By default, zone.js will patch all possible macroTask and DomEvents 3629 * user can disable parts of macroTask/DomEvents patch by setting following flags 3630 * because those flags need to be set before `zone.js` being loaded, and webpack 3631 * will put import in the top of bundle, so user need to create a separate file
3632 * in this directory (for example: zone-flags.ts), and put the following flags 3633 * into that file, and then add the following code before importing zone.js. 3634 * import './zone-flags'; 3635 * 3636 * The flags allowed in zone-flags.ts are listed here. 3637 * 3638 * The following flags will work for all browsers. 3639 * 3640 * (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame 3641 * (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick 3642 * (window as any).__zone_symbol__UNPATCHED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames 3643 * 3644 * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js 3645 * with the following flag, it will bypass `zone.js` patch for IE/Edge 3646 * 3647 * (window as any).__Zone_enable_cross_context_check = true; 3648 * 3649 */ 3650 3651/*************************************************************************************************** 3652 * Zone JS is required by default for Angular itself. 3653 */ 3654 // Included with Angular CLI. 3655/*************************************************************************************************** 3656 * APPLICATION IMPORTS 3657 */ 3658 3659 3660/***/ }), 3661 3662/***/ 28270:
vendor: 8,524 bytes, lines 3663-3905
3663/*!***************************!*\ 3664 !*** ./src/zone-flags.ts ***! 3665 \***************************/ 3666/***/ (() => { 3667 3668/** 3669 * Prevents Angular change detection from 3670 * running with certain Web Component callbacks 3671 */ 3672// eslint-disable-next-line no-underscore-dangle 3673window.__Zone_disable_customElements = true; 3674 3675 3676/***/ }), 3677 3678/***/ 97625: 3679/*!******************************************************!*\ 3680 !*** ./node_modules/core-js/internals/a-function.js ***! 3681 \******************************************************/ 3682/***/ ((module) => { 3683 3684module.exports = function (it) { 3685 if (typeof it != 'function') { 3686 throw TypeError(String(it) + ' is not a function'); 3687 } return it; 3688}; 3689 3690 3691/***/ }), 3692 3693/***/ 95143: 3694/*!****************************************************************!*\ 3695 !*** ./node_modules/core-js/internals/a-possible-prototype.js ***! 3696 \****************************************************************/ 3697/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3698 3699var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 3700 3701module.exports = function (it) { 3702 if (!isObject(it) && it !== null) { 3703 throw TypeError("Can't set " + String(it) + ' as a prototype'); 3704 } return it; 3705}; 3706 3707 3708/***/ }), 3709 3710/***/ 86063: 3711/*!*******************************************************!*\ 3712 !*** ./node_modules/core-js/internals/an-instance.js ***! 3713 \*******************************************************/ 3714/***/ ((module) => { 3715 3716module.exports = function (it, Constructor, name) { 3717 if (!(it instanceof Constructor)) { 3718 throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); 3719 } return it; 3720}; 3721 3722 3723/***/ }), 3724 3725/***/ 21099: 3726/*!*****************************************************!*\ 3727 !*** ./node_modules/core-js/internals/an-object.js ***! 3728 \*****************************************************/ 3729/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3730 3731var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 3732 3733module.exports = function (it) { 3734 if (!isObject(it)) { 3735 throw TypeError(String(it) + ' is not an object'); 3736 } return it; 3737}; 3738 3739 3740/***/ }), 3741 3742/***/ 70452: 3743/*!**********************************************************!*\ 3744 !*** ./node_modules/core-js/internals/array-includes.js ***! 3745 \**********************************************************/ 3746/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3747 3748var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ 8643); 3749var toLength = __webpack_require__(/*! ../internals/to-length */ 15902); 3750var toAbsoluteIndex = __webpack_require__(/*! ../internals/to-absolute-index */ 20222); 3751 3752// `Array.prototype.{ indexOf, includes }` methods implementation 3753var createMethod = function (IS_INCLUDES) { 3754 return function ($this, el, fromIndex) { 3755 var O = toIndexedObject($this); 3756 var length = toLength(O.length); 3757 var index = toAbsoluteIndex(fromIndex, length); 3758 var value; 3759 // Array#includes uses SameValueZero equality algorithm 3760 // eslint-disable-next-line no-self-compare -- NaN check 3761 if (IS_INCLUDES && el != el) while (length > index) { 3762 value = O[index++]; 3763 // eslint-disable-next-line no-self-compare -- NaN check 3764 if (value != value) return true; 3765 // Array#indexOf ignores holes, Array#includes - not 3766 } else for (;length > index; index++) { 3767 if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; 3768 } return !IS_INCLUDES && -1; 3769 }; 3770}; 3771 3772module.exports = { 3773 // `Array.prototype.includes` method 3774 // https://tc39.es/ecma262/#sec-array.prototype.includes 3775 includes: createMethod(true), 3776 // `Array.prototype.indexOf` method 3777 // https://tc39.es/ecma262/#sec-array.prototype.indexof 3778 indexOf: createMethod(false) 3779}; 3780 3781 3782/***/ }), 3783 3784/***/ 94115: 3785/*!***********************************************************!*\ 3786 !*** ./node_modules/core-js/internals/array-iteration.js ***! 3787 \***********************************************************/ 3788/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3789 3790var bind = __webpack_require__(/*! ../internals/function-bind-context */ 29727); 3791var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ 56169); 3792var toObject = __webpack_require__(/*! ../internals/to-object */ 16174); 3793var toLength = __webpack_require__(/*! ../internals/to-length */ 15902); 3794var arraySpeciesCreate = __webpack_require__(/*! ../internals/array-species-create */ 62889); 3795 3796var push = [].push; 3797 3798// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterOut }` methods implementation 3799var createMethod = function (TYPE) { 3800 var IS_MAP = TYPE == 1; 3801 var IS_FILTER = TYPE == 2; 3802 var IS_SOME = TYPE == 3; 3803 var IS_EVERY = TYPE == 4; 3804 var IS_FIND_INDEX = TYPE == 6; 3805 var IS_FILTER_OUT = TYPE == 7; 3806 var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; 3807 return function ($this, callbackfn, that, specificCreate) { 3808 var O = toObject($this); 3809 var self = IndexedObject(O); 3810 var boundFunction = bind(callbackfn, that, 3); 3811 var length = toLength(self.length); 3812 var index = 0; 3813 var create = specificCreate || arraySpeciesCreate; 3814 var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_OUT ? create($this, 0) : undefined; 3815 var value, result; 3816 for (;length > index; index++) if (NO_HOLES || index in self) { 3817 value = self[index]; 3818 result = boundFunction(value, index, O); 3819 if (TYPE) { 3820 if (IS_MAP) target[index] = result; // map 3821 else if (result) switch (TYPE) { 3822 case 3: return true; // some 3823 case 5: return value; // find 3824 case 6: return index; // findIndex 3825 case 2: push.call(target, value); // filter 3826 } else switch (TYPE) { 3827 case 4: return false; // every 3828 case 7: push.call(target, value); // filterOut 3829 } 3830 } 3831 } 3832 return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; 3833 }; 3834}; 3835 3836module.exports = { 3837 // `Array.prototype.forEach` method 3838 // https://tc39.es/ecma262/#sec-array.prototype.foreach 3839 forEach: createMethod(0), 3840 // `Array.prototype.map` method 3841 // https://tc39.es/ecma262/#sec-array.prototype.map 3842 map: createMethod(1), 3843 // `Array.prototype.filter` method 3844 // https://tc39.es/ecma262/#sec-array.prototype.filter 3845 filter: createMethod(2), 3846 // `Array.prototype.some` method 3847 // https://tc39.es/ecma262/#sec-array.prototype.some 3848 some: createMethod(3), 3849 // `Array.prototype.every` method 3850 // https://tc39.es/ecma262/#sec-array.prototype.every 3851 every: createMethod(4), 3852 // `Array.prototype.find` method 3853 // https://tc39.es/ecma262/#sec-array.prototype.find 3854 find: createMethod(5), 3855 // `Array.prototype.findIndex` method 3856 // https://tc39.es/ecma262/#sec-array.prototype.findIndex 3857 findIndex: createMethod(6), 3858 // `Array.prototype.filterOut` method 3859 // https://github.com/tc39/proposal-array-filtering 3860 filterOut: createMethod(7) 3861}; 3862 3863 3864/***/ }), 3865 3866/***/ 62889: 3867/*!****************************************************************!*\ 3868 !*** ./node_modules/core-js/internals/array-species-create.js ***! 3869 \****************************************************************/ 3870/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3871 3872var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 3873var isArray = __webpack_require__(/*! ../internals/is-array */ 47883); 3874var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 3875 3876var SPECIES = wellKnownSymbol('species'); 3877 3878// `ArraySpeciesCreate` abstract operation 3879// https://tc39.es/ecma262/#sec-arrayspeciescreate 3880module.exports = function (originalArray, length) { 3881 var C; 3882 if (isArray(originalArray)) { 3883 C = originalArray.constructor; 3884 // cross-realm fallback 3885 if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; 3886 else if (isObject(C)) { 3887 C = C[SPECIES]; 3888 if (C === null) C = undefined; 3889 } 3890 } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); 3891}; 3892 3893 3894/***/ }), 3895 3896/***/ 56297: 3897/*!**************************************************************************!*\ 3898 !*** ./node_modules/core-js/internals/check-correctness-of-iteration.js ***! 3899 \**************************************************************************/ 3900/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3901 3902var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 3903 3904var ITERATOR = wellKnownSymbol('iterator'); 3905var SAFE_CLOSING = false;
vendor: 11,042 bytes, lines 3906-4215
3906 3907try { 3908 var called = 0; 3909 var iteratorWithReturn = { 3910 next: function () { 3911 return { done: !!called++ }; 3912 }, 3913 'return': function () { 3914 SAFE_CLOSING = true; 3915 } 3916 }; 3917 iteratorWithReturn[ITERATOR] = function () { 3918 return this; 3919 }; 3920 // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing 3921 Array.from(iteratorWithReturn, function () { throw 2; }); 3922} catch (error) { /* empty */ } 3923 3924module.exports = function (exec, SKIP_CLOSING) { 3925 if (!SKIP_CLOSING && !SAFE_CLOSING) return false; 3926 var ITERATION_SUPPORT = false; 3927 try { 3928 var object = {}; 3929 object[ITERATOR] = function () { 3930 return { 3931 next: function () { 3932 return { done: ITERATION_SUPPORT = true }; 3933 } 3934 }; 3935 }; 3936 exec(object); 3937 } catch (error) { /* empty */ } 3938 return ITERATION_SUPPORT; 3939}; 3940 3941 3942/***/ }), 3943 3944/***/ 96644: 3945/*!*******************************************************!*\ 3946 !*** ./node_modules/core-js/internals/classof-raw.js ***! 3947 \*******************************************************/ 3948/***/ ((module) => { 3949 3950var toString = {}.toString; 3951 3952module.exports = function (it) { 3953 return toString.call(it).slice(8, -1); 3954}; 3955 3956 3957/***/ }), 3958 3959/***/ 99420: 3960/*!***************************************************!*\ 3961 !*** ./node_modules/core-js/internals/classof.js ***! 3962 \***************************************************/ 3963/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3964 3965var TO_STRING_TAG_SUPPORT = __webpack_require__(/*! ../internals/to-string-tag-support */ 72900); 3966var classofRaw = __webpack_require__(/*! ../internals/classof-raw */ 96644); 3967var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 3968 3969var TO_STRING_TAG = wellKnownSymbol('toStringTag'); 3970// ES3 wrong here 3971var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; 3972 3973// fallback for IE11 Script Access Denied error 3974var tryGet = function (it, key) { 3975 try { 3976 return it[key]; 3977 } catch (error) { /* empty */ } 3978}; 3979 3980// getting tag from ES6+ `Object.prototype.toString` 3981module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { 3982 var O, tag, result; 3983 return it === undefined ? 'Undefined' : it === null ? 'Null' 3984 // @@toStringTag case 3985 : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag 3986 // builtinTag case 3987 : CORRECT_ARGUMENTS ? classofRaw(O) 3988 // ES3 arguments fallback 3989 : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; 3990}; 3991 3992 3993/***/ }), 3994 3995/***/ 5692: 3996/*!*************************************************************!*\ 3997 !*** ./node_modules/core-js/internals/collection-strong.js ***! 3998 \*************************************************************/ 3999/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4000 4001"use strict"; 4002 4003var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ 52975).f; 4004var create = __webpack_require__(/*! ../internals/object-create */ 38724); 4005var redefineAll = __webpack_require__(/*! ../internals/redefine-all */ 78715); 4006var bind = __webpack_require__(/*! ../internals/function-bind-context */ 29727); 4007var anInstance = __webpack_require__(/*! ../internals/an-instance */ 86063); 4008var iterate = __webpack_require__(/*! ../internals/iterate */ 53284); 4009var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ 66038); 4010var setSpecies = __webpack_require__(/*! ../internals/set-species */ 37374); 4011var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 4012var fastKey = __webpack_require__(/*! ../internals/internal-metadata */ 64238).fastKey; 4013var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ 52493); 4014 4015var setInternalState = InternalStateModule.set; 4016var internalStateGetterFor = InternalStateModule.getterFor; 4017 4018module.exports = { 4019 getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { 4020 var C = wrapper(function (that, iterable) { 4021 anInstance(that, C, CONSTRUCTOR_NAME); 4022 setInternalState(that, { 4023 type: CONSTRUCTOR_NAME, 4024 index: create(null), 4025 first: undefined, 4026 last: undefined, 4027 size: 0 4028 }); 4029 if (!DESCRIPTORS) that.size = 0; 4030 if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); 4031 }); 4032 4033 var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); 4034 4035 var define = function (that, key, value) { 4036 var state = getInternalState(that); 4037 var entry = getEntry(that, key); 4038 var previous, index; 4039 // change existing entry 4040 if (entry) { 4041 entry.value = value; 4042 // create new entry 4043 } else { 4044 state.last = entry = { 4045 index: index = fastKey(key, true), 4046 key: key, 4047 value: value, 4048 previous: previous = state.last, 4049 next: undefined, 4050 removed: false 4051 }; 4052 if (!state.first) state.first = entry; 4053 if (previous) previous.next = entry; 4054 if (DESCRIPTORS) state.size++; 4055 else that.size++; 4056 // add to index 4057 if (index !== 'F') state.index[index] = entry; 4058 } return that; 4059 }; 4060 4061 var getEntry = function (that, key) { 4062 var state = getInternalState(that); 4063 // fast case 4064 var index = fastKey(key); 4065 var entry; 4066 if (index !== 'F') return state.index[index]; 4067 // frozen object case 4068 for (entry = state.first; entry; entry = entry.next) { 4069 if (entry.key == key) return entry; 4070 } 4071 }; 4072 4073 redefineAll(C.prototype, { 4074 // 23.1.3.1 Map.prototype.clear() 4075 // 23.2.3.2 Set.prototype.clear() 4076 clear: function clear() { 4077 var that = this; 4078 var state = getInternalState(that); 4079 var data = state.index; 4080 var entry = state.first; 4081 while (entry) { 4082 entry.removed = true; 4083 if (entry.previous) entry.previous = entry.previous.next = undefined; 4084 delete data[entry.index]; 4085 entry = entry.next; 4086 } 4087 state.first = state.last = undefined; 4088 if (DESCRIPTORS) state.size = 0; 4089 else that.size = 0; 4090 }, 4091 // 23.1.3.3 Map.prototype.delete(key) 4092 // 23.2.3.4 Set.prototype.delete(value) 4093 'delete': function (key) { 4094 var that = this; 4095 var state = getInternalState(that); 4096 var entry = getEntry(that, key); 4097 if (entry) { 4098 var next = entry.next; 4099 var prev = entry.previous; 4100 delete state.index[entry.index]; 4101 entry.removed = true; 4102 if (prev) prev.next = next; 4103 if (next) next.previous = prev; 4104 if (state.first == entry) state.first = next; 4105 if (state.last == entry) state.last = prev; 4106 if (DESCRIPTORS) state.size--; 4107 else that.size--; 4108 } return !!entry; 4109 }, 4110 // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) 4111 // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) 4112 forEach: function forEach(callbackfn /* , that = undefined */) { 4113 var state = getInternalState(this); 4114 var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); 4115 var entry; 4116 while (entry = entry ? entry.next : state.first) { 4117 boundFunction(entry.value, entry.key, this); 4118 // revert to the last existing entry 4119 while (entry && entry.removed) entry = entry.previous; 4120 } 4121 }, 4122 // 23.1.3.7 Map.prototype.has(key) 4123 // 23.2.3.7 Set.prototype.has(value) 4124 has: function has(key) { 4125 return !!getEntry(this, key); 4126 } 4127 }); 4128 4129 redefineAll(C.prototype, IS_MAP ? { 4130 // 23.1.3.6 Map.prototype.get(key) 4131 get: function get(key) { 4132 var entry = getEntry(this, key); 4133 return entry && entry.value; 4134 }, 4135 // 23.1.3.9 Map.prototype.set(key, value) 4136 set: function set(key, value) { 4137 return define(this, key === 0 ? 0 : key, value); 4138 } 4139 } : { 4140 // 23.2.3.1 Set.prototype.add(value) 4141 add: function add(value) { 4142 return define(this, value = value === 0 ? 0 : value, value); 4143 } 4144 }); 4145 if (DESCRIPTORS) defineProperty(C.prototype, 'size', { 4146 get: function () { 4147 return getInternalState(this).size; 4148 } 4149 }); 4150 return C; 4151 }, 4152 setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) { 4153 var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; 4154 var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); 4155 var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); 4156 // add .keys, .values, .entries, [@@iterator] 4157 // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 4158 defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) { 4159 setInternalState(this, { 4160 type: ITERATOR_NAME, 4161 target: iterated, 4162 state: getInternalCollectionState(iterated), 4163 kind: kind, 4164 last: undefined 4165 }); 4166 }, function () { 4167 var state = getInternalIteratorState(this); 4168 var kind = state.kind; 4169 var entry = state.last; 4170 // revert to the last existing entry 4171 while (entry && entry.removed) entry = entry.previous; 4172 // get next entry 4173 if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { 4174 // or finish the iteration 4175 state.target = undefined; 4176 return { value: undefined, done: true }; 4177 } 4178 // return step by kind 4179 if (kind == 'keys') return { value: entry.key, done: false }; 4180 if (kind == 'values') return { value: entry.value, done: false }; 4181 return { value: [entry.key, entry.value], done: false }; 4182 }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); 4183 4184 // add [@@species], 23.1.2.2, 23.2.2.2 4185 setSpecies(CONSTRUCTOR_NAME); 4186 } 4187}; 4188 4189 4190/***/ }), 4191 4192/***/ 96491: 4193/*!***********************************************************!*\ 4194 !*** ./node_modules/core-js/internals/collection-weak.js ***! 4195 \***********************************************************/ 4196/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4197 4198"use strict"; 4199 4200var redefineAll = __webpack_require__(/*! ../internals/redefine-all */ 78715); 4201var getWeakData = __webpack_require__(/*! ../internals/internal-metadata */ 64238).getWeakData; 4202var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 4203var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 4204var anInstance = __webpack_require__(/*! ../internals/an-instance */ 86063); 4205var iterate = __webpack_require__(/*! ../internals/iterate */ 53284); 4206var ArrayIterationModule = __webpack_require__(/*! ../internals/array-iteration */ 94115); 4207var $has = __webpack_require__(/*! ../internals/has */ 67791); 4208var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ 52493); 4209 4210var setInternalState = InternalStateModule.set; 4211var internalStateGetterFor = InternalStateModule.getterFor; 4212var find = ArrayIterationModule.find; 4213var findIndex = ArrayIterationModule.findIndex; 4214var id = 0; 4215
vendor: 5,774 bytes, lines 4216-4375
4216// fallback for uncaught frozen keys 4217var uncaughtFrozenStore = function (store) { 4218 return store.frozen || (store.frozen = new UncaughtFrozenStore()); 4219}; 4220 4221var UncaughtFrozenStore = function () { 4222 this.entries = []; 4223}; 4224 4225var findUncaughtFrozen = function (store, key) { 4226 return find(store.entries, function (it) { 4227 return it[0] === key; 4228 }); 4229}; 4230 4231UncaughtFrozenStore.prototype = { 4232 get: function (key) { 4233 var entry = findUncaughtFrozen(this, key); 4234 if (entry) return entry[1]; 4235 }, 4236 has: function (key) { 4237 return !!findUncaughtFrozen(this, key); 4238 }, 4239 set: function (key, value) { 4240 var entry = findUncaughtFrozen(this, key); 4241 if (entry) entry[1] = value; 4242 else this.entries.push([key, value]); 4243 }, 4244 'delete': function (key) { 4245 var index = findIndex(this.entries, function (it) { 4246 return it[0] === key; 4247 }); 4248 if (~index) this.entries.splice(index, 1); 4249 return !!~index; 4250 } 4251}; 4252 4253module.exports = { 4254 getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { 4255 var C = wrapper(function (that, iterable) { 4256 anInstance(that, C, CONSTRUCTOR_NAME); 4257 setInternalState(that, { 4258 type: CONSTRUCTOR_NAME, 4259 id: id++, 4260 frozen: undefined 4261 }); 4262 if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); 4263 }); 4264 4265 var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); 4266 4267 var define = function (that, key, value) { 4268 var state = getInternalState(that); 4269 var data = getWeakData(anObject(key), true); 4270 if (data === true) uncaughtFrozenStore(state).set(key, value); 4271 else data[state.id] = value; 4272 return that; 4273 }; 4274 4275 redefineAll(C.prototype, { 4276 // 23.3.3.2 WeakMap.prototype.delete(key) 4277 // 23.4.3.3 WeakSet.prototype.delete(value) 4278 'delete': function (key) { 4279 var state = getInternalState(this); 4280 if (!isObject(key)) return false; 4281 var data = getWeakData(key); 4282 if (data === true) return uncaughtFrozenStore(state)['delete'](key); 4283 return data && $has(data, state.id) && delete data[state.id]; 4284 }, 4285 // 23.3.3.4 WeakMap.prototype.has(key) 4286 // 23.4.3.4 WeakSet.prototype.has(value) 4287 has: function has(key) { 4288 var state = getInternalState(this); 4289 if (!isObject(key)) return false; 4290 var data = getWeakData(key); 4291 if (data === true) return uncaughtFrozenStore(state).has(key); 4292 return data && $has(data, state.id); 4293 } 4294 }); 4295 4296 redefineAll(C.prototype, IS_MAP ? { 4297 // 23.3.3.3 WeakMap.prototype.get(key) 4298 get: function get(key) { 4299 var state = getInternalState(this); 4300 if (isObject(key)) { 4301 var data = getWeakData(key); 4302 if (data === true) return uncaughtFrozenStore(state).get(key); 4303 return data ? data[state.id] : undefined; 4304 } 4305 }, 4306 // 23.3.3.5 WeakMap.prototype.set(key, value) 4307 set: function set(key, value) { 4308 return define(this, key, value); 4309 } 4310 } : { 4311 // 23.4.3.1 WeakSet.prototype.add(value) 4312 add: function add(value) { 4313 return define(this, value, true); 4314 } 4315 }); 4316 4317 return C; 4318 } 4319}; 4320 4321 4322/***/ }), 4323 4324/***/ 41603: 4325/*!******************************************************!*\ 4326 !*** ./node_modules/core-js/internals/collection.js ***! 4327 \******************************************************/ 4328/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4329 4330"use strict"; 4331 4332var $ = __webpack_require__(/*! ../internals/export */ 51163); 4333var global = __webpack_require__(/*! ../internals/global */ 31864); 4334var isForced = __webpack_require__(/*! ../internals/is-forced */ 87215); 4335var redefine = __webpack_require__(/*! ../internals/redefine */ 87763); 4336var InternalMetadataModule = __webpack_require__(/*! ../internals/internal-metadata */ 64238); 4337var iterate = __webpack_require__(/*! ../internals/iterate */ 53284); 4338var anInstance = __webpack_require__(/*! ../internals/an-instance */ 86063); 4339var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 4340var fails = __webpack_require__(/*! ../internals/fails */ 8597); 4341var checkCorrectnessOfIteration = __webpack_require__(/*! ../internals/check-correctness-of-iteration */ 56297); 4342var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ 58242); 4343var inheritIfRequired = __webpack_require__(/*! ../internals/inherit-if-required */ 38267); 4344 4345module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { 4346 var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; 4347 var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; 4348 var ADDER = IS_MAP ? 'set' : 'add'; 4349 var NativeConstructor = global[CONSTRUCTOR_NAME]; 4350 var NativePrototype = NativeConstructor && NativeConstructor.prototype; 4351 var Constructor = NativeConstructor; 4352 var exported = {}; 4353 4354 var fixMethod = function (KEY) { 4355 var nativeMethod = NativePrototype[KEY]; 4356 redefine(NativePrototype, KEY, 4357 KEY == 'add' ? function add(value) { 4358 nativeMethod.call(this, value === 0 ? 0 : value); 4359 return this; 4360 } : KEY == 'delete' ? function (key) { 4361 return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); 4362 } : KEY == 'get' ? function get(key) { 4363 return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key); 4364 } : KEY == 'has' ? function has(key) { 4365 return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); 4366 } : function set(key, value) { 4367 nativeMethod.call(this, key === 0 ? 0 : key, value); 4368 return this; 4369 } 4370 ); 4371 }; 4372 4373 var REPLACE = isForced( 4374 CONSTRUCTOR_NAME, 4375 typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {
vendor: 7,789 bytes, lines 4376-4566
4376 new NativeConstructor().entries().next(); 4377 })) 4378 ); 4379 4380 if (REPLACE) { 4381 // create collection constructor 4382 Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); 4383 InternalMetadataModule.REQUIRED = true; 4384 } else if (isForced(CONSTRUCTOR_NAME, true)) { 4385 var instance = new Constructor(); 4386 // early implementations not supports chaining 4387 var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; 4388 // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false 4389 var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); 4390 // most early implementations doesn't supports iterables, most modern - not close it correctly 4391 // eslint-disable-next-line no-new -- required for testing 4392 var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); 4393 // for early implementations -0 and +0 not the same 4394 var BUGGY_ZERO = !IS_WEAK && fails(function () { 4395 // V8 ~ Chromium 42- fails only with 5+ elements 4396 var $instance = new NativeConstructor(); 4397 var index = 5; 4398 while (index--) $instance[ADDER](index, index); 4399 return !$instance.has(-0); 4400 }); 4401 4402 if (!ACCEPT_ITERABLES) { 4403 Constructor = wrapper(function (dummy, iterable) { 4404 anInstance(dummy, Constructor, CONSTRUCTOR_NAME); 4405 var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); 4406 if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); 4407 return that; 4408 }); 4409 Constructor.prototype = NativePrototype; 4410 NativePrototype.constructor = Constructor; 4411 } 4412 4413 if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { 4414 fixMethod('delete'); 4415 fixMethod('has'); 4416 IS_MAP && fixMethod('get'); 4417 } 4418 4419 if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); 4420 4421 // weak collections should not contains .clear method 4422 if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; 4423 } 4424 4425 exported[CONSTRUCTOR_NAME] = Constructor; 4426 $({ global: true, forced: Constructor != NativeConstructor }, exported); 4427 4428 setToStringTag(Constructor, CONSTRUCTOR_NAME); 4429 4430 if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); 4431 4432 return Constructor; 4433}; 4434 4435 4436/***/ }), 4437 4438/***/ 30009: 4439/*!***********************************************************************!*\ 4440 !*** ./node_modules/core-js/internals/copy-constructor-properties.js ***! 4441 \***********************************************************************/ 4442/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4443 4444var has = __webpack_require__(/*! ../internals/has */ 67791); 4445var ownKeys = __webpack_require__(/*! ../internals/own-keys */ 99376); 4446var getOwnPropertyDescriptorModule = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ 93099); 4447var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ 52975); 4448 4449module.exports = function (target, source) { 4450 var keys = ownKeys(source); 4451 var defineProperty = definePropertyModule.f; 4452 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; 4453 for (var i = 0; i < keys.length; i++) { 4454 var key = keys[i]; 4455 if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); 4456 } 4457}; 4458 4459 4460/***/ }), 4461 4462/***/ 51335: 4463/*!********************************************************************!*\ 4464 !*** ./node_modules/core-js/internals/correct-prototype-getter.js ***! 4465 \********************************************************************/ 4466/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4467 4468var fails = __webpack_require__(/*! ../internals/fails */ 8597); 4469 4470module.exports = !fails(function () { 4471 function F() { /* empty */ } 4472 F.prototype.constructor = null; 4473 // eslint-disable-next-line es/no-object-getprototypeof -- required for testing 4474 return Object.getPrototypeOf(new F()) !== F.prototype; 4475}); 4476 4477 4478/***/ }), 4479 4480/***/ 17453: 4481/*!***********************************************************************!*\ 4482 !*** ./node_modules/core-js/internals/create-iterator-constructor.js ***! 4483 \***********************************************************************/ 4484/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4485 4486"use strict"; 4487 4488var IteratorPrototype = __webpack_require__(/*! ../internals/iterators-core */ 92053).IteratorPrototype; 4489var create = __webpack_require__(/*! ../internals/object-create */ 38724); 4490var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ 53203); 4491var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ 58242); 4492var Iterators = __webpack_require__(/*! ../internals/iterators */ 72339); 4493 4494var returnThis = function () { return this; }; 4495 4496module.exports = function (IteratorConstructor, NAME, next) { 4497 var TO_STRING_TAG = NAME + ' Iterator'; 4498 IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) }); 4499 setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); 4500 Iterators[TO_STRING_TAG] = returnThis; 4501 return IteratorConstructor; 4502}; 4503 4504 4505/***/ }), 4506 4507/***/ 815: 4508/*!**************************************************************************!*\ 4509 !*** ./node_modules/core-js/internals/create-non-enumerable-property.js ***! 4510 \**************************************************************************/ 4511/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4512 4513var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 4514var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ 52975); 4515var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ 53203); 4516 4517module.exports = DESCRIPTORS ? function (object, key, value) { 4518 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); 4519} : function (object, key, value) { 4520 object[key] = value; 4521 return object; 4522}; 4523 4524 4525/***/ }), 4526 4527/***/ 53203: 4528/*!**********************************************************************!*\ 4529 !*** ./node_modules/core-js/internals/create-property-descriptor.js ***! 4530 \**********************************************************************/ 4531/***/ ((module) => { 4532 4533module.exports = function (bitmap, value) { 4534 return { 4535 enumerable: !(bitmap & 1), 4536 configurable: !(bitmap & 2), 4537 writable: !(bitmap & 4), 4538 value: value 4539 }; 4540}; 4541 4542 4543/***/ }), 4544 4545/***/ 66038: 4546/*!***********************************************************!*\ 4547 !*** ./node_modules/core-js/internals/define-iterator.js ***! 4548 \***********************************************************/ 4549/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4550 4551"use strict"; 4552 4553var $ = __webpack_require__(/*! ../internals/export */ 51163); 4554var createIteratorConstructor = __webpack_require__(/*! ../internals/create-iterator-constructor */ 17453); 4555var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ 3963); 4556var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ 91464); 4557var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ 58242); 4558var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ 815); 4559var redefine = __webpack_require__(/*! ../internals/redefine */ 87763); 4560var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 4561var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ 97515); 4562var Iterators = __webpack_require__(/*! ../internals/iterators */ 72339); 4563var IteratorsCore = __webpack_require__(/*! ../internals/iterators-core */ 92053); 4564 4565var IteratorPrototype = IteratorsCore.IteratorPrototype; 4566var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
vendor: 6,206 bytes, lines 4567-4737
4567var ITERATOR = wellKnownSymbol('iterator'); 4568var KEYS = 'keys'; 4569var VALUES = 'values'; 4570var ENTRIES = 'entries'; 4571 4572var returnThis = function () { return this; }; 4573 4574module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { 4575 createIteratorConstructor(IteratorConstructor, NAME, next); 4576 4577 var getIterationMethod = function (KIND) { 4578 if (KIND === DEFAULT && defaultIterator) return defaultIterator; 4579 if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND]; 4580 switch (KIND) { 4581 case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; 4582 case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; 4583 case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; 4584 } return function () { return new IteratorConstructor(this); }; 4585 }; 4586 4587 var TO_STRING_TAG = NAME + ' Iterator'; 4588 var INCORRECT_VALUES_NAME = false; 4589 var IterablePrototype = Iterable.prototype; 4590 var nativeIterator = IterablePrototype[ITERATOR] 4591 || IterablePrototype['@@iterator'] 4592 || DEFAULT && IterablePrototype[DEFAULT]; 4593 var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); 4594 var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; 4595 var CurrentIteratorPrototype, methods, KEY; 4596 4597 // fix native 4598 if (anyNativeIterator) { 4599 CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); 4600 if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { 4601 if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { 4602 if (setPrototypeOf) { 4603 setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); 4604 } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') { 4605 createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis); 4606 } 4607 } 4608 // Set @@toStringTag to native iterators 4609 setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); 4610 if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis; 4611 } 4612 } 4613 4614 // fix Array#{values, @@iterator}.name in V8 / FF 4615 if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { 4616 INCORRECT_VALUES_NAME = true; 4617 defaultIterator = function values() { return nativeIterator.call(this); }; 4618 } 4619 4620 // define iterator 4621 if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { 4622 createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator); 4623 } 4624 Iterators[NAME] = defaultIterator; 4625 4626 // export additional methods 4627 if (DEFAULT) { 4628 methods = { 4629 values: getIterationMethod(VALUES), 4630 keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), 4631 entries: getIterationMethod(ENTRIES) 4632 }; 4633 if (FORCED) for (KEY in methods) { 4634 if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { 4635 redefine(IterablePrototype, KEY, methods[KEY]); 4636 } 4637 } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); 4638 } 4639 4640 return methods; 4641}; 4642 4643 4644/***/ }), 4645 4646/***/ 47012: 4647/*!*******************************************************!*\ 4648 !*** ./node_modules/core-js/internals/descriptors.js ***! 4649 \*******************************************************/ 4650/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4651 4652var fails = __webpack_require__(/*! ../internals/fails */ 8597); 4653 4654// Detect IE8's incomplete defineProperty implementation 4655module.exports = !fails(function () { 4656 // eslint-disable-next-line es/no-object-defineproperty -- required for testing 4657 return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7; 4658}); 4659 4660 4661/***/ }), 4662 4663/***/ 85815: 4664/*!*******************************************************************!*\ 4665 !*** ./node_modules/core-js/internals/document-create-element.js ***! 4666 \*******************************************************************/ 4667/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4668 4669var global = __webpack_require__(/*! ../internals/global */ 31864); 4670var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 4671 4672var document = global.document; 4673// typeof document.createElement is 'object' in old IE 4674var EXISTS = isObject(document) && isObject(document.createElement); 4675 4676module.exports = function (it) { 4677 return EXISTS ? document.createElement(it) : {}; 4678}; 4679 4680 4681/***/ }), 4682 4683/***/ 73792: 4684/*!*************************************************************!*\ 4685 !*** ./node_modules/core-js/internals/engine-user-agent.js ***! 4686 \*************************************************************/ 4687/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4688 4689var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ 73626); 4690 4691module.exports = getBuiltIn('navigator', 'userAgent') || ''; 4692 4693 4694/***/ }), 4695 4696/***/ 17189: 4697/*!*************************************************************!*\ 4698 !*** ./node_modules/core-js/internals/engine-v8-version.js ***! 4699 \*************************************************************/ 4700/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4701 4702var global = __webpack_require__(/*! ../internals/global */ 31864); 4703var userAgent = __webpack_require__(/*! ../internals/engine-user-agent */ 73792); 4704 4705var process = global.process; 4706var versions = process && process.versions; 4707var v8 = versions && versions.v8; 4708var match, version; 4709 4710if (v8) { 4711 match = v8.split('.'); 4712 version = match[0] < 4 ? 1 : match[0] + match[1]; 4713} else if (userAgent) { 4714 match = userAgent.match(/Edge\/(\d+)/); 4715 if (!match || match[1] >= 74) { 4716 match = userAgent.match(/Chrome\/(\d+)/); 4717 if (match) version = match[1]; 4718 } 4719} 4720 4721module.exports = version && +version; 4722 4723 4724/***/ }), 4725 4726/***/ 71001: 4727/*!*********************************************************!*\ 4728 !*** ./node_modules/core-js/internals/enum-bug-keys.js ***! 4729 \*********************************************************/ 4730/***/ ((module) => { 4731 4732// IE8- don't enum bug keys 4733module.exports = [ 4734 'constructor', 4735 'hasOwnProperty', 4736 'isPrototypeOf', 4737 'propertyIsEnumerable',
vendor: 4,239 bytes, lines 4738-4850
4738 'toLocaleString', 4739 'toString', 4740 'valueOf' 4741]; 4742 4743 4744/***/ }), 4745 4746/***/ 51163: 4747/*!**************************************************!*\ 4748 !*** ./node_modules/core-js/internals/export.js ***! 4749 \**************************************************/ 4750/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4751 4752var global = __webpack_require__(/*! ../internals/global */ 31864); 4753var getOwnPropertyDescriptor = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ 93099).f; 4754var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ 815); 4755var redefine = __webpack_require__(/*! ../internals/redefine */ 87763); 4756var setGlobal = __webpack_require__(/*! ../internals/set-global */ 22341); 4757var copyConstructorProperties = __webpack_require__(/*! ../internals/copy-constructor-properties */ 30009); 4758var isForced = __webpack_require__(/*! ../internals/is-forced */ 87215); 4759 4760/* 4761 options.target - name of the target object 4762 options.global - target is the global object 4763 options.stat - export as static methods of target 4764 options.proto - export as prototype methods of target 4765 options.real - real prototype method for the `pure` version 4766 options.forced - export even if the native feature is available 4767 options.bind - bind methods to the target, required for the `pure` version 4768 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version 4769 options.unsafe - use the simple assignment of property instead of delete + defineProperty 4770 options.sham - add a flag to not completely full polyfills 4771 options.enumerable - export as enumerable property 4772 options.noTargetGet - prevent calling a getter on target 4773*/ 4774module.exports = function (options, source) { 4775 var TARGET = options.target; 4776 var GLOBAL = options.global; 4777 var STATIC = options.stat; 4778 var FORCED, target, key, targetProperty, sourceProperty, descriptor; 4779 if (GLOBAL) { 4780 target = global; 4781 } else if (STATIC) { 4782 target = global[TARGET] || setGlobal(TARGET, {}); 4783 } else { 4784 target = (global[TARGET] || {}).prototype; 4785 } 4786 if (target) for (key in source) { 4787 sourceProperty = source[key]; 4788 if (options.noTargetGet) { 4789 descriptor = getOwnPropertyDescriptor(target, key); 4790 targetProperty = descriptor && descriptor.value; 4791 } else targetProperty = target[key]; 4792 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); 4793 // contained in target 4794 if (!FORCED && targetProperty !== undefined) { 4795 if (typeof sourceProperty === typeof targetProperty) continue; 4796 copyConstructorProperties(sourceProperty, targetProperty); 4797 } 4798 // add a flag to not completely full polyfills 4799 if (options.sham || (targetProperty && targetProperty.sham)) { 4800 createNonEnumerableProperty(sourceProperty, 'sham', true); 4801 } 4802 // extend global 4803 redefine(target, key, sourceProperty, options); 4804 } 4805}; 4806 4807 4808/***/ }), 4809 4810/***/ 8597: 4811/*!*************************************************!*\ 4812 !*** ./node_modules/core-js/internals/fails.js ***! 4813 \*************************************************/ 4814/***/ ((module) => { 4815 4816module.exports = function (exec) { 4817 try { 4818 return !!exec(); 4819 } catch (error) { 4820 return true; 4821 } 4822}; 4823 4824 4825/***/ }), 4826 4827/***/ 39352: 4828/*!****************************************************!*\ 4829 !*** ./node_modules/core-js/internals/freezing.js ***! 4830 \****************************************************/ 4831/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4832 4833var fails = __webpack_require__(/*! ../internals/fails */ 8597); 4834 4835module.exports = !fails(function () { 4836 // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing 4837 return Object.isExtensible(Object.preventExtensions({})); 4838}); 4839 4840 4841/***/ }), 4842 4843/***/ 29727: 4844/*!*****************************************************************!*\ 4845 !*** ./node_modules/core-js/internals/function-bind-context.js ***! 4846 \*****************************************************************/ 4847/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4848 4849var aFunction = __webpack_require__(/*! ../internals/a-function */ 97625); 4850
vendor: 9,062 bytes, lines 4851-5124
4851// optional / simple context binding 4852module.exports = function (fn, that, length) { 4853 aFunction(fn); 4854 if (that === undefined) return fn; 4855 switch (length) { 4856 case 0: return function () { 4857 return fn.call(that); 4858 }; 4859 case 1: return function (a) { 4860 return fn.call(that, a); 4861 }; 4862 case 2: return function (a, b) { 4863 return fn.call(that, a, b); 4864 }; 4865 case 3: return function (a, b, c) { 4866 return fn.call(that, a, b, c); 4867 }; 4868 } 4869 return function (/* ...args */) { 4870 return fn.apply(that, arguments); 4871 }; 4872}; 4873 4874 4875/***/ }), 4876 4877/***/ 73626: 4878/*!********************************************************!*\ 4879 !*** ./node_modules/core-js/internals/get-built-in.js ***! 4880 \********************************************************/ 4881/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4882 4883var path = __webpack_require__(/*! ../internals/path */ 86950); 4884var global = __webpack_require__(/*! ../internals/global */ 31864); 4885 4886var aFunction = function (variable) { 4887 return typeof variable == 'function' ? variable : undefined; 4888}; 4889 4890module.exports = function (namespace, method) { 4891 return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) 4892 : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method]; 4893}; 4894 4895 4896/***/ }), 4897 4898/***/ 63076: 4899/*!***************************************************************!*\ 4900 !*** ./node_modules/core-js/internals/get-iterator-method.js ***! 4901 \***************************************************************/ 4902/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4903 4904var classof = __webpack_require__(/*! ../internals/classof */ 99420); 4905var Iterators = __webpack_require__(/*! ../internals/iterators */ 72339); 4906var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 4907 4908var ITERATOR = wellKnownSymbol('iterator'); 4909 4910module.exports = function (it) { 4911 if (it != undefined) return it[ITERATOR] 4912 || it['@@iterator'] 4913 || Iterators[classof(it)]; 4914}; 4915 4916 4917/***/ }), 4918 4919/***/ 31864: 4920/*!**************************************************!*\ 4921 !*** ./node_modules/core-js/internals/global.js ***! 4922 \**************************************************/ 4923/***/ ((module) => { 4924 4925var check = function (it) { 4926 return it && it.Math == Math && it; 4927}; 4928 4929// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 4930module.exports = 4931 // eslint-disable-next-line es/no-global-this -- safe 4932 check(typeof globalThis == 'object' && globalThis) || 4933 check(typeof window == 'object' && window) || 4934 // eslint-disable-next-line no-restricted-globals -- safe 4935 check(typeof self == 'object' && self) || 4936 check(typeof global == 'object' && global) || 4937 // eslint-disable-next-line no-new-func -- fallback 4938 (function () { return this; })() || Function('return this')(); 4939 4940 4941/***/ }), 4942 4943/***/ 67791: 4944/*!***********************************************!*\ 4945 !*** ./node_modules/core-js/internals/has.js ***! 4946 \***********************************************/ 4947/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4948 4949var toObject = __webpack_require__(/*! ../internals/to-object */ 16174); 4950 4951var hasOwnProperty = {}.hasOwnProperty; 4952 4953module.exports = function hasOwn(it, key) { 4954 return hasOwnProperty.call(toObject(it), key); 4955}; 4956 4957 4958/***/ }), 4959 4960/***/ 3536: 4961/*!*******************************************************!*\ 4962 !*** ./node_modules/core-js/internals/hidden-keys.js ***! 4963 \*******************************************************/ 4964/***/ ((module) => { 4965 4966module.exports = {}; 4967 4968 4969/***/ }), 4970 4971/***/ 67538: 4972/*!************************************************!*\ 4973 !*** ./node_modules/core-js/internals/html.js ***! 4974 \************************************************/ 4975/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4976 4977var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ 73626); 4978 4979module.exports = getBuiltIn('document', 'documentElement'); 4980 4981 4982/***/ }), 4983 4984/***/ 27091: 4985/*!**********************************************************!*\ 4986 !*** ./node_modules/core-js/internals/ie8-dom-define.js ***! 4987 \**********************************************************/ 4988/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4989 4990var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 4991var fails = __webpack_require__(/*! ../internals/fails */ 8597); 4992var createElement = __webpack_require__(/*! ../internals/document-create-element */ 85815); 4993 4994// Thank's IE8 for his funny defineProperty 4995module.exports = !DESCRIPTORS && !fails(function () { 4996 // eslint-disable-next-line es/no-object-defineproperty -- requied for testing 4997 return Object.defineProperty(createElement('div'), 'a', { 4998 get: function () { return 7; } 4999 }).a != 7; 5000}); 5001 5002 5003/***/ }), 5004 5005/***/ 56169: 5006/*!**********************************************************!*\ 5007 !*** ./node_modules/core-js/internals/indexed-object.js ***! 5008 \**********************************************************/ 5009/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5010 5011var fails = __webpack_require__(/*! ../internals/fails */ 8597); 5012var classof = __webpack_require__(/*! ../internals/classof-raw */ 96644); 5013 5014var split = ''.split; 5015 5016// fallback for non-array-like ES3 and non-enumerable old V8 strings 5017module.exports = fails(function () { 5018 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 5019 // eslint-disable-next-line no-prototype-builtins -- safe 5020 return !Object('z').propertyIsEnumerable(0); 5021}) ? function (it) { 5022 return classof(it) == 'String' ? split.call(it, '') : Object(it); 5023} : Object; 5024 5025 5026/***/ }), 5027 5028/***/ 38267: 5029/*!***************************************************************!*\ 5030 !*** ./node_modules/core-js/internals/inherit-if-required.js ***! 5031 \***************************************************************/ 5032/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5033 5034var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 5035var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ 91464); 5036 5037// makes subclassing work correct for wrapped built-ins 5038module.exports = function ($this, dummy, Wrapper) { 5039 var NewTarget, NewTargetPrototype; 5040 if ( 5041 // it can work only with native `setPrototypeOf` 5042 setPrototypeOf && 5043 // we haven't completely correct pre-ES6 way for getting `new.target`, so use this 5044 typeof (NewTarget = dummy.constructor) == 'function' && 5045 NewTarget !== Wrapper && 5046 isObject(NewTargetPrototype = NewTarget.prototype) && 5047 NewTargetPrototype !== Wrapper.prototype 5048 ) setPrototypeOf($this, NewTargetPrototype); 5049 return $this; 5050}; 5051 5052 5053/***/ }), 5054 5055/***/ 87720: 5056/*!**********************************************************!*\ 5057 !*** ./node_modules/core-js/internals/inspect-source.js ***! 5058 \**********************************************************/ 5059/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5060 5061var store = __webpack_require__(/*! ../internals/shared-store */ 59941); 5062 5063var functionToString = Function.toString; 5064 5065// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper 5066if (typeof store.inspectSource != 'function') { 5067 store.inspectSource = function (it) { 5068 return functionToString.call(it); 5069 }; 5070} 5071 5072module.exports = store.inspectSource; 5073 5074 5075/***/ }), 5076 5077/***/ 64238: 5078/*!*************************************************************!*\ 5079 !*** ./node_modules/core-js/internals/internal-metadata.js ***! 5080 \*************************************************************/ 5081/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5082 5083var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ 3536); 5084var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 5085var has = __webpack_require__(/*! ../internals/has */ 67791); 5086var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ 52975).f; 5087var uid = __webpack_require__(/*! ../internals/uid */ 94295); 5088var FREEZING = __webpack_require__(/*! ../internals/freezing */ 39352); 5089 5090var METADATA = uid('meta'); 5091var id = 0; 5092 5093// eslint-disable-next-line es/no-object-isextensible -- safe 5094var isExtensible = Object.isExtensible || function () { 5095 return true; 5096}; 5097 5098var setMetadata = function (it) { 5099 defineProperty(it, METADATA, { value: { 5100 objectID: 'O' + ++id, // object ID 5101 weakData: {} // weak collections IDs 5102 } }); 5103}; 5104 5105var fastKey = function (it, create) { 5106 // return a primitive with prefix 5107 if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; 5108 if (!has(it, METADATA)) { 5109 // can't set metadata to uncaught frozen object 5110 if (!isExtensible(it)) return 'F'; 5111 // not necessary to add metadata 5112 if (!create) return 'E'; 5113 // add missing metadata 5114 setMetadata(it); 5115 // return object ID 5116 } return it[METADATA].objectID; 5117}; 5118 5119var getWeakData = function (it, create) { 5120 if (!has(it, METADATA)) { 5121 // can't set metadata to uncaught frozen object 5122 if (!isExtensible(it)) return true; 5123 // not necessary to add metadata 5124 if (!create) return false;
vendor: 5,575 bytes, lines 5125-5314
5125 // add missing metadata 5126 setMetadata(it); 5127 // return the store of weak collections IDs 5128 } return it[METADATA].weakData; 5129}; 5130 5131// add metadata on freeze-family methods calling 5132var onFreeze = function (it) { 5133 if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); 5134 return it; 5135}; 5136 5137var meta = module.exports = { 5138 REQUIRED: false, 5139 fastKey: fastKey, 5140 getWeakData: getWeakData, 5141 onFreeze: onFreeze 5142}; 5143 5144hiddenKeys[METADATA] = true; 5145 5146 5147/***/ }), 5148 5149/***/ 52493: 5150/*!**********************************************************!*\ 5151 !*** ./node_modules/core-js/internals/internal-state.js ***! 5152 \**********************************************************/ 5153/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5154 5155var NATIVE_WEAK_MAP = __webpack_require__(/*! ../internals/native-weak-map */ 51635); 5156var global = __webpack_require__(/*! ../internals/global */ 31864); 5157var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 5158var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ 815); 5159var objectHas = __webpack_require__(/*! ../internals/has */ 67791); 5160var shared = __webpack_require__(/*! ../internals/shared-store */ 59941); 5161var sharedKey = __webpack_require__(/*! ../internals/shared-key */ 42650); 5162var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ 3536); 5163 5164var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; 5165var WeakMap = global.WeakMap; 5166var set, get, has; 5167 5168var enforce = function (it) { 5169 return has(it) ? get(it) : set(it, {}); 5170}; 5171 5172var getterFor = function (TYPE) { 5173 return function (it) { 5174 var state; 5175 if (!isObject(it) || (state = get(it)).type !== TYPE) { 5176 throw TypeError('Incompatible receiver, ' + TYPE + ' required'); 5177 } return state; 5178 }; 5179}; 5180 5181if (NATIVE_WEAK_MAP) { 5182 var store = shared.state || (shared.state = new WeakMap()); 5183 var wmget = store.get; 5184 var wmhas = store.has; 5185 var wmset = store.set; 5186 set = function (it, metadata) { 5187 if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); 5188 metadata.facade = it; 5189 wmset.call(store, it, metadata); 5190 return metadata; 5191 }; 5192 get = function (it) { 5193 return wmget.call(store, it) || {}; 5194 }; 5195 has = function (it) { 5196 return wmhas.call(store, it); 5197 }; 5198} else { 5199 var STATE = sharedKey('state'); 5200 hiddenKeys[STATE] = true; 5201 set = function (it, metadata) { 5202 if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); 5203 metadata.facade = it; 5204 createNonEnumerableProperty(it, STATE, metadata); 5205 return metadata; 5206 }; 5207 get = function (it) { 5208 return objectHas(it, STATE) ? it[STATE] : {}; 5209 }; 5210 has = function (it) { 5211 return objectHas(it, STATE); 5212 }; 5213} 5214 5215module.exports = { 5216 set: set, 5217 get: get, 5218 has: has, 5219 enforce: enforce, 5220 getterFor: getterFor 5221}; 5222 5223 5224/***/ }), 5225 5226/***/ 81643: 5227/*!********************************************************************!*\ 5228 !*** ./node_modules/core-js/internals/is-array-iterator-method.js ***! 5229 \********************************************************************/ 5230/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5231 5232var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 5233var Iterators = __webpack_require__(/*! ../internals/iterators */ 72339); 5234 5235var ITERATOR = wellKnownSymbol('iterator'); 5236var ArrayPrototype = Array.prototype; 5237 5238// check on default Array iterator 5239module.exports = function (it) { 5240 return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); 5241}; 5242 5243 5244/***/ }), 5245 5246/***/ 47883: 5247/*!****************************************************!*\ 5248 !*** ./node_modules/core-js/internals/is-array.js ***! 5249 \****************************************************/ 5250/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5251 5252var classof = __webpack_require__(/*! ../internals/classof-raw */ 96644); 5253 5254// `IsArray` abstract operation 5255// https://tc39.es/ecma262/#sec-isarray 5256// eslint-disable-next-line es/no-array-isarray -- safe 5257module.exports = Array.isArray || function isArray(arg) { 5258 return classof(arg) == 'Array'; 5259}; 5260 5261 5262/***/ }), 5263 5264/***/ 87215: 5265/*!*****************************************************!*\ 5266 !*** ./node_modules/core-js/internals/is-forced.js ***! 5267 \*****************************************************/ 5268/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5269 5270var fails = __webpack_require__(/*! ../internals/fails */ 8597); 5271 5272var replacement = /#|\.prototype\./; 5273 5274var isForced = function (feature, detection) { 5275 var value = data[normalize(feature)]; 5276 return value == POLYFILL ? true 5277 : value == NATIVE ? false 5278 : typeof detection == 'function' ? fails(detection) 5279 : !!detection; 5280}; 5281 5282var normalize = isForced.normalize = function (string) { 5283 return String(string).replace(replacement, '.').toLowerCase(); 5284}; 5285 5286var data = isForced.data = {}; 5287var NATIVE = isForced.NATIVE = 'N'; 5288var POLYFILL = isForced.POLYFILL = 'P'; 5289 5290module.exports = isForced; 5291 5292 5293/***/ }), 5294 5295/***/ 60726: 5296/*!*****************************************************!*\ 5297 !*** ./node_modules/core-js/internals/is-object.js ***! 5298 \*****************************************************/ 5299/***/ ((module) => { 5300 5301module.exports = function (it) { 5302 return typeof it === 'object' ? it !== null : typeof it === 'function'; 5303}; 5304 5305 5306/***/ }), 5307 5308/***/ 97515: 5309/*!***************************************************!*\ 5310 !*** ./node_modules/core-js/internals/is-pure.js ***! 5311 \***************************************************/ 5312/***/ ((module) => { 5313 5314module.exports = false;
vendor: 8,358 bytes, lines 5315-5545
5315 5316 5317/***/ }), 5318 5319/***/ 53284: 5320/*!***************************************************!*\ 5321 !*** ./node_modules/core-js/internals/iterate.js ***! 5322 \***************************************************/ 5323/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5324 5325var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5326var isArrayIteratorMethod = __webpack_require__(/*! ../internals/is-array-iterator-method */ 81643); 5327var toLength = __webpack_require__(/*! ../internals/to-length */ 15902); 5328var bind = __webpack_require__(/*! ../internals/function-bind-context */ 29727); 5329var getIteratorMethod = __webpack_require__(/*! ../internals/get-iterator-method */ 63076); 5330var iteratorClose = __webpack_require__(/*! ../internals/iterator-close */ 87883); 5331 5332var Result = function (stopped, result) { 5333 this.stopped = stopped; 5334 this.result = result; 5335}; 5336 5337module.exports = function (iterable, unboundFunction, options) { 5338 var that = options && options.that; 5339 var AS_ENTRIES = !!(options && options.AS_ENTRIES); 5340 var IS_ITERATOR = !!(options && options.IS_ITERATOR); 5341 var INTERRUPTED = !!(options && options.INTERRUPTED); 5342 var fn = bind(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED); 5343 var iterator, iterFn, index, length, result, next, step; 5344 5345 var stop = function (condition) { 5346 if (iterator) iteratorClose(iterator); 5347 return new Result(true, condition); 5348 }; 5349 5350 var callFn = function (value) { 5351 if (AS_ENTRIES) { 5352 anObject(value); 5353 return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); 5354 } return INTERRUPTED ? fn(value, stop) : fn(value); 5355 }; 5356 5357 if (IS_ITERATOR) { 5358 iterator = iterable; 5359 } else { 5360 iterFn = getIteratorMethod(iterable); 5361 if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); 5362 // optimisation for array iterators 5363 if (isArrayIteratorMethod(iterFn)) { 5364 for (index = 0, length = toLength(iterable.length); length > index; index++) { 5365 result = callFn(iterable[index]); 5366 if (result && result instanceof Result) return result; 5367 } return new Result(false); 5368 } 5369 iterator = iterFn.call(iterable); 5370 } 5371 5372 next = iterator.next; 5373 while (!(step = next.call(iterator)).done) { 5374 try { 5375 result = callFn(step.value); 5376 } catch (error) { 5377 iteratorClose(iterator); 5378 throw error; 5379 } 5380 if (typeof result == 'object' && result && result instanceof Result) return result; 5381 } return new Result(false); 5382}; 5383 5384 5385/***/ }), 5386 5387/***/ 87883: 5388/*!**********************************************************!*\ 5389 !*** ./node_modules/core-js/internals/iterator-close.js ***! 5390 \**********************************************************/ 5391/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5392 5393var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5394 5395module.exports = function (iterator) { 5396 var returnMethod = iterator['return']; 5397 if (returnMethod !== undefined) { 5398 return anObject(returnMethod.call(iterator)).value; 5399 } 5400}; 5401 5402 5403/***/ }), 5404 5405/***/ 92053: 5406/*!**********************************************************!*\ 5407 !*** ./node_modules/core-js/internals/iterators-core.js ***! 5408 \**********************************************************/ 5409/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5410 5411"use strict"; 5412 5413var fails = __webpack_require__(/*! ../internals/fails */ 8597); 5414var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ 3963); 5415var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ 815); 5416var has = __webpack_require__(/*! ../internals/has */ 67791); 5417var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 5418var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ 97515); 5419 5420var ITERATOR = wellKnownSymbol('iterator'); 5421var BUGGY_SAFARI_ITERATORS = false; 5422 5423var returnThis = function () { return this; }; 5424 5425// `%IteratorPrototype%` object 5426// https://tc39.es/ecma262/#sec-%iteratorprototype%-object 5427var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; 5428 5429/* eslint-disable es/no-array-prototype-keys -- safe */ 5430if ([].keys) { 5431 arrayIterator = [].keys(); 5432 // Safari 8 has buggy iterators w/o `next` 5433 if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; 5434 else { 5435 PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); 5436 if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; 5437 } 5438} 5439 5440var NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () { 5441 var test = {}; 5442 // FF44- legacy iterators case 5443 return IteratorPrototype[ITERATOR].call(test) !== test; 5444}); 5445 5446if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {}; 5447 5448// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() 5449if ((!IS_PURE || NEW_ITERATOR_PROTOTYPE) && !has(IteratorPrototype, ITERATOR)) { 5450 createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis); 5451} 5452 5453module.exports = { 5454 IteratorPrototype: IteratorPrototype, 5455 BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS 5456}; 5457 5458 5459/***/ }), 5460 5461/***/ 72339: 5462/*!*****************************************************!*\ 5463 !*** ./node_modules/core-js/internals/iterators.js ***! 5464 \*****************************************************/ 5465/***/ ((module) => { 5466 5467module.exports = {}; 5468 5469 5470/***/ }), 5471 5472/***/ 77040: 5473/*!*********************************************************!*\ 5474 !*** ./node_modules/core-js/internals/native-symbol.js ***! 5475 \*********************************************************/ 5476/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5477 5478/* eslint-disable es/no-symbol -- required for testing */ 5479var V8_VERSION = __webpack_require__(/*! ../internals/engine-v8-version */ 17189); 5480var fails = __webpack_require__(/*! ../internals/fails */ 8597); 5481 5482// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing 5483module.exports = !!Object.getOwnPropertySymbols && !fails(function () { 5484 return !String(Symbol()) || 5485 // Chrome 38 Symbol has incorrect toString conversion 5486 // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances 5487 !Symbol.sham && V8_VERSION && V8_VERSION < 41; 5488}); 5489 5490 5491/***/ }), 5492 5493/***/ 51635: 5494/*!***********************************************************!*\ 5495 !*** ./node_modules/core-js/internals/native-weak-map.js ***! 5496 \***********************************************************/ 5497/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5498 5499var global = __webpack_require__(/*! ../internals/global */ 31864); 5500var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ 87720); 5501 5502var WeakMap = global.WeakMap; 5503 5504module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap)); 5505 5506 5507/***/ }), 5508 5509/***/ 38724: 5510/*!*********************************************************!*\ 5511 !*** ./node_modules/core-js/internals/object-create.js ***! 5512 \*********************************************************/ 5513/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5514 5515var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5516var defineProperties = __webpack_require__(/*! ../internals/object-define-properties */ 10988); 5517var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ 71001); 5518var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ 3536); 5519var html = __webpack_require__(/*! ../internals/html */ 67538); 5520var documentCreateElement = __webpack_require__(/*! ../internals/document-create-element */ 85815); 5521var sharedKey = __webpack_require__(/*! ../internals/shared-key */ 42650); 5522 5523var GT = '>'; 5524var LT = '<'; 5525var PROTOTYPE = 'prototype'; 5526var SCRIPT = 'script'; 5527var IE_PROTO = sharedKey('IE_PROTO'); 5528 5529var EmptyConstructor = function () { /* empty */ }; 5530 5531var scriptTag = function (content) { 5532 return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; 5533}; 5534 5535// Create object with fake `null` prototype: use ActiveX Object with cleared prototype 5536var NullProtoObjectViaActiveX = function (activeXDocument) { 5537 activeXDocument.write(scriptTag('')); 5538 activeXDocument.close(); 5539 var temp = activeXDocument.parentWindow.Object; 5540 activeXDocument = null; // avoid memory leak 5541 return temp; 5542}; 5543 5544// Create object with fake `null` prototype: use iframe Object with cleared prototype 5545var NullProtoObjectViaIFrame = function () {
vendor: 10,034 bytes, lines 5546-5796
5546 // Thrash, waste and sodomy: IE GC bug 5547 var iframe = documentCreateElement('iframe'); 5548 var JS = 'java' + SCRIPT + ':'; 5549 var iframeDocument; 5550 iframe.style.display = 'none'; 5551 html.appendChild(iframe); 5552 // https://github.com/zloirock/core-js/issues/475 5553 iframe.src = String(JS); 5554 iframeDocument = iframe.contentWindow.document; 5555 iframeDocument.open(); 5556 iframeDocument.write(scriptTag('document.F=Object')); 5557 iframeDocument.close(); 5558 return iframeDocument.F; 5559}; 5560 5561// Check for document.domain and active x support 5562// No need to use active x approach when document.domain is not set 5563// see https://github.com/es-shims/es5-shim/issues/150 5564// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 5565// avoid IE GC bug 5566var activeXDocument; 5567var NullProtoObject = function () { 5568 try { 5569 /* global ActiveXObject -- old IE */ 5570 activeXDocument = document.domain && new ActiveXObject('htmlfile'); 5571 } catch (error) { /* ignore */ } 5572 NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); 5573 var length = enumBugKeys.length; 5574 while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; 5575 return NullProtoObject(); 5576}; 5577 5578hiddenKeys[IE_PROTO] = true; 5579 5580// `Object.create` method 5581// https://tc39.es/ecma262/#sec-object.create 5582module.exports = Object.create || function create(O, Properties) { 5583 var result; 5584 if (O !== null) { 5585 EmptyConstructor[PROTOTYPE] = anObject(O); 5586 result = new EmptyConstructor(); 5587 EmptyConstructor[PROTOTYPE] = null; 5588 // add "__proto__" for Object.getPrototypeOf polyfill 5589 result[IE_PROTO] = O; 5590 } else result = NullProtoObject(); 5591 return Properties === undefined ? result : defineProperties(result, Properties); 5592}; 5593 5594 5595/***/ }), 5596 5597/***/ 10988: 5598/*!********************************************************************!*\ 5599 !*** ./node_modules/core-js/internals/object-define-properties.js ***! 5600 \********************************************************************/ 5601/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5602 5603var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 5604var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ 52975); 5605var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5606var objectKeys = __webpack_require__(/*! ../internals/object-keys */ 68032); 5607 5608// `Object.defineProperties` method 5609// https://tc39.es/ecma262/#sec-object.defineproperties 5610// eslint-disable-next-line es/no-object-defineproperties -- safe 5611module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { 5612 anObject(O); 5613 var keys = objectKeys(Properties); 5614 var length = keys.length; 5615 var index = 0; 5616 var key; 5617 while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]); 5618 return O; 5619}; 5620 5621 5622/***/ }), 5623 5624/***/ 52975: 5625/*!******************************************************************!*\ 5626 !*** ./node_modules/core-js/internals/object-define-property.js ***! 5627 \******************************************************************/ 5628/***/ ((__unused_webpack_module, exports, __webpack_require__) => { 5629 5630var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 5631var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ 27091); 5632var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5633var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ 28495); 5634 5635// eslint-disable-next-line es/no-object-defineproperty -- safe 5636var $defineProperty = Object.defineProperty; 5637 5638// `Object.defineProperty` method 5639// https://tc39.es/ecma262/#sec-object.defineproperty 5640exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) { 5641 anObject(O); 5642 P = toPrimitive(P, true); 5643 anObject(Attributes); 5644 if (IE8_DOM_DEFINE) try { 5645 return $defineProperty(O, P, Attributes); 5646 } catch (error) { /* empty */ } 5647 if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); 5648 if ('value' in Attributes) O[P] = Attributes.value; 5649 return O; 5650}; 5651 5652 5653/***/ }), 5654 5655/***/ 93099: 5656/*!******************************************************************************!*\ 5657 !*** ./node_modules/core-js/internals/object-get-own-property-descriptor.js ***! 5658 \******************************************************************************/ 5659/***/ ((__unused_webpack_module, exports, __webpack_require__) => { 5660 5661var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 5662var propertyIsEnumerableModule = __webpack_require__(/*! ../internals/object-property-is-enumerable */ 5600); 5663var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ 53203); 5664var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ 8643); 5665var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ 28495); 5666var has = __webpack_require__(/*! ../internals/has */ 67791); 5667var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ 27091); 5668 5669// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 5670var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 5671 5672// `Object.getOwnPropertyDescriptor` method 5673// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor 5674exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { 5675 O = toIndexedObject(O); 5676 P = toPrimitive(P, true); 5677 if (IE8_DOM_DEFINE) try { 5678 return $getOwnPropertyDescriptor(O, P); 5679 } catch (error) { /* empty */ } 5680 if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); 5681}; 5682 5683 5684/***/ }), 5685 5686/***/ 94564: 5687/*!*************************************************************************!*\ 5688 !*** ./node_modules/core-js/internals/object-get-own-property-names.js ***! 5689 \*************************************************************************/ 5690/***/ ((__unused_webpack_module, exports, __webpack_require__) => { 5691 5692var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ 77759); 5693var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ 71001); 5694 5695var hiddenKeys = enumBugKeys.concat('length', 'prototype'); 5696 5697// `Object.getOwnPropertyNames` method 5698// https://tc39.es/ecma262/#sec-object.getownpropertynames 5699// eslint-disable-next-line es/no-object-getownpropertynames -- safe 5700exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { 5701 return internalObjectKeys(O, hiddenKeys); 5702}; 5703 5704 5705/***/ }), 5706 5707/***/ 77593: 5708/*!***************************************************************************!*\ 5709 !*** ./node_modules/core-js/internals/object-get-own-property-symbols.js ***! 5710 \***************************************************************************/ 5711/***/ ((__unused_webpack_module, exports) => { 5712 5713// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe 5714exports.f = Object.getOwnPropertySymbols; 5715 5716 5717/***/ }), 5718 5719/***/ 3963: 5720/*!*******************************************************************!*\ 5721 !*** ./node_modules/core-js/internals/object-get-prototype-of.js ***! 5722 \*******************************************************************/ 5723/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5724 5725var has = __webpack_require__(/*! ../internals/has */ 67791); 5726var toObject = __webpack_require__(/*! ../internals/to-object */ 16174); 5727var sharedKey = __webpack_require__(/*! ../internals/shared-key */ 42650); 5728var CORRECT_PROTOTYPE_GETTER = __webpack_require__(/*! ../internals/correct-prototype-getter */ 51335); 5729 5730var IE_PROTO = sharedKey('IE_PROTO'); 5731var ObjectPrototype = Object.prototype; 5732 5733// `Object.getPrototypeOf` method 5734// https://tc39.es/ecma262/#sec-object.getprototypeof 5735// eslint-disable-next-line es/no-object-getprototypeof -- safe 5736module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) { 5737 O = toObject(O); 5738 if (has(O, IE_PROTO)) return O[IE_PROTO]; 5739 if (typeof O.constructor == 'function' && O instanceof O.constructor) { 5740 return O.constructor.prototype; 5741 } return O instanceof Object ? ObjectPrototype : null; 5742}; 5743 5744 5745/***/ }), 5746 5747/***/ 77759: 5748/*!****************************************************************!*\ 5749 !*** ./node_modules/core-js/internals/object-keys-internal.js ***! 5750 \****************************************************************/ 5751/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5752 5753var has = __webpack_require__(/*! ../internals/has */ 67791); 5754var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ 8643); 5755var indexOf = __webpack_require__(/*! ../internals/array-includes */ 70452).indexOf; 5756var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ 3536); 5757 5758module.exports = function (object, names) { 5759 var O = toIndexedObject(object); 5760 var i = 0; 5761 var result = []; 5762 var key; 5763 for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); 5764 // Don't enum bug & hidden keys 5765 while (names.length > i) if (has(O, key = names[i++])) { 5766 ~indexOf(result, key) || result.push(key); 5767 } 5768 return result; 5769}; 5770 5771 5772/***/ }), 5773 5774/***/ 68032: 5775/*!*******************************************************!*\ 5776 !*** ./node_modules/core-js/internals/object-keys.js ***! 5777 \*******************************************************/ 5778/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5779 5780var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ 77759); 5781var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ 71001); 5782 5783// `Object.keys` method 5784// https://tc39.es/ecma262/#sec-object.keys 5785// eslint-disable-next-line es/no-object-keys -- safe 5786module.exports = Object.keys || function keys(O) { 5787 return internalObjectKeys(O, enumBugKeys); 5788}; 5789 5790 5791/***/ }), 5792 5793/***/ 5600: 5794/*!*************************************************************************!*\ 5795 !*** ./node_modules/core-js/internals/object-property-is-enumerable.js ***! 5796 \*************************************************************************/
vendor: 18,970 bytes, lines 5797-6340
5797/***/ ((__unused_webpack_module, exports) => { 5798 5799"use strict"; 5800 5801var $propertyIsEnumerable = {}.propertyIsEnumerable; 5802// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 5803var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 5804 5805// Nashorn ~ JDK8 bug 5806var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); 5807 5808// `Object.prototype.propertyIsEnumerable` method implementation 5809// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable 5810exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { 5811 var descriptor = getOwnPropertyDescriptor(this, V); 5812 return !!descriptor && descriptor.enumerable; 5813} : $propertyIsEnumerable; 5814 5815 5816/***/ }), 5817 5818/***/ 91464: 5819/*!*******************************************************************!*\ 5820 !*** ./node_modules/core-js/internals/object-set-prototype-of.js ***! 5821 \*******************************************************************/ 5822/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5823 5824/* eslint-disable no-proto -- safe */ 5825var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5826var aPossiblePrototype = __webpack_require__(/*! ../internals/a-possible-prototype */ 95143); 5827 5828// `Object.setPrototypeOf` method 5829// https://tc39.es/ecma262/#sec-object.setprototypeof 5830// Works with __proto__ only. Old v8 can't work with null proto objects. 5831// eslint-disable-next-line es/no-object-setprototypeof -- safe 5832module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { 5833 var CORRECT_SETTER = false; 5834 var test = {}; 5835 var setter; 5836 try { 5837 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 5838 setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; 5839 setter.call(test, []); 5840 CORRECT_SETTER = test instanceof Array; 5841 } catch (error) { /* empty */ } 5842 return function setPrototypeOf(O, proto) { 5843 anObject(O); 5844 aPossiblePrototype(proto); 5845 if (CORRECT_SETTER) setter.call(O, proto); 5846 else O.__proto__ = proto; 5847 return O; 5848 }; 5849}() : undefined); 5850 5851 5852/***/ }), 5853 5854/***/ 99376: 5855/*!****************************************************!*\ 5856 !*** ./node_modules/core-js/internals/own-keys.js ***! 5857 \****************************************************/ 5858/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5859 5860var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ 73626); 5861var getOwnPropertyNamesModule = __webpack_require__(/*! ../internals/object-get-own-property-names */ 94564); 5862var getOwnPropertySymbolsModule = __webpack_require__(/*! ../internals/object-get-own-property-symbols */ 77593); 5863var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 5864 5865// all object keys, includes non-enumerable and symbols 5866module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { 5867 var keys = getOwnPropertyNamesModule.f(anObject(it)); 5868 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; 5869 return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; 5870}; 5871 5872 5873/***/ }), 5874 5875/***/ 86950: 5876/*!************************************************!*\ 5877 !*** ./node_modules/core-js/internals/path.js ***! 5878 \************************************************/ 5879/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5880 5881var global = __webpack_require__(/*! ../internals/global */ 31864); 5882 5883module.exports = global; 5884 5885 5886/***/ }), 5887 5888/***/ 78715: 5889/*!********************************************************!*\ 5890 !*** ./node_modules/core-js/internals/redefine-all.js ***! 5891 \********************************************************/ 5892/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5893 5894var redefine = __webpack_require__(/*! ../internals/redefine */ 87763); 5895 5896module.exports = function (target, src, options) { 5897 for (var key in src) redefine(target, key, src[key], options); 5898 return target; 5899}; 5900 5901 5902/***/ }), 5903 5904/***/ 87763: 5905/*!****************************************************!*\ 5906 !*** ./node_modules/core-js/internals/redefine.js ***! 5907 \****************************************************/ 5908/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5909 5910var global = __webpack_require__(/*! ../internals/global */ 31864); 5911var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ 815); 5912var has = __webpack_require__(/*! ../internals/has */ 67791); 5913var setGlobal = __webpack_require__(/*! ../internals/set-global */ 22341); 5914var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ 87720); 5915var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ 52493); 5916 5917var getInternalState = InternalStateModule.get; 5918var enforceInternalState = InternalStateModule.enforce; 5919var TEMPLATE = String(String).split('String'); 5920 5921(module.exports = function (O, key, value, options) { 5922 var unsafe = options ? !!options.unsafe : false; 5923 var simple = options ? !!options.enumerable : false; 5924 var noTargetGet = options ? !!options.noTargetGet : false; 5925 var state; 5926 if (typeof value == 'function') { 5927 if (typeof key == 'string' && !has(value, 'name')) { 5928 createNonEnumerableProperty(value, 'name', key); 5929 } 5930 state = enforceInternalState(value); 5931 if (!state.source) { 5932 state.source = TEMPLATE.join(typeof key == 'string' ? key : ''); 5933 } 5934 } 5935 if (O === global) { 5936 if (simple) O[key] = value; 5937 else setGlobal(key, value); 5938 return; 5939 } else if (!unsafe) { 5940 delete O[key]; 5941 } else if (!noTargetGet && O[key]) { 5942 simple = true; 5943 } 5944 if (simple) O[key] = value; 5945 else createNonEnumerableProperty(O, key, value); 5946// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative 5947})(Function.prototype, 'toString', function toString() { 5948 return typeof this == 'function' && getInternalState(this).source || inspectSource(this); 5949}); 5950 5951 5952/***/ }), 5953 5954/***/ 54230: 5955/*!************************************************************!*\ 5956 !*** ./node_modules/core-js/internals/reflect-metadata.js ***! 5957 \************************************************************/ 5958/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5959 5960// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` 5961var Map = __webpack_require__(/*! ../modules/es.map */ 88854); 5962var WeakMap = __webpack_require__(/*! ../modules/es.weak-map */ 63438); 5963var shared = __webpack_require__(/*! ../internals/shared */ 77719); 5964 5965var metadata = shared('metadata'); 5966var store = metadata.store || (metadata.store = new WeakMap()); 5967 5968var getOrCreateMetadataMap = function (target, targetKey, create) { 5969 var targetMetadata = store.get(target); 5970 if (!targetMetadata) { 5971 if (!create) return; 5972 store.set(target, targetMetadata = new Map()); 5973 } 5974 var keyMetadata = targetMetadata.get(targetKey); 5975 if (!keyMetadata) { 5976 if (!create) return; 5977 targetMetadata.set(targetKey, keyMetadata = new Map()); 5978 } return keyMetadata; 5979}; 5980 5981var ordinaryHasOwnMetadata = function (MetadataKey, O, P) { 5982 var metadataMap = getOrCreateMetadataMap(O, P, false); 5983 return metadataMap === undefined ? false : metadataMap.has(MetadataKey); 5984}; 5985 5986var ordinaryGetOwnMetadata = function (MetadataKey, O, P) { 5987 var metadataMap = getOrCreateMetadataMap(O, P, false); 5988 return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey); 5989}; 5990 5991var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) { 5992 getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue); 5993}; 5994 5995var ordinaryOwnMetadataKeys = function (target, targetKey) { 5996 var metadataMap = getOrCreateMetadataMap(target, targetKey, false); 5997 var keys = []; 5998 if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); }); 5999 return keys; 6000}; 6001 6002var toMetadataKey = function (it) { 6003 return it === undefined || typeof it == 'symbol' ? it : String(it); 6004}; 6005 6006module.exports = { 6007 store: store, 6008 getMap: getOrCreateMetadataMap, 6009 has: ordinaryHasOwnMetadata, 6010 get: ordinaryGetOwnMetadata, 6011 set: ordinaryDefineOwnMetadata, 6012 keys: ordinaryOwnMetadataKeys, 6013 toKey: toMetadataKey 6014}; 6015 6016 6017/***/ }), 6018 6019/***/ 95025: 6020/*!********************************************************************!*\ 6021 !*** ./node_modules/core-js/internals/require-object-coercible.js ***! 6022 \********************************************************************/ 6023/***/ ((module) => { 6024 6025// `RequireObjectCoercible` abstract operation 6026// https://tc39.es/ecma262/#sec-requireobjectcoercible 6027module.exports = function (it) { 6028 if (it == undefined) throw TypeError("Can't call method on " + it); 6029 return it; 6030}; 6031 6032 6033/***/ }), 6034 6035/***/ 22341: 6036/*!******************************************************!*\ 6037 !*** ./node_modules/core-js/internals/set-global.js ***! 6038 \******************************************************/ 6039/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6040 6041var global = __webpack_require__(/*! ../internals/global */ 31864); 6042var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ 815); 6043 6044module.exports = function (key, value) { 6045 try { 6046 createNonEnumerableProperty(global, key, value); 6047 } catch (error) { 6048 global[key] = value; 6049 } return value; 6050}; 6051 6052 6053/***/ }), 6054 6055/***/ 37374: 6056/*!*******************************************************!*\ 6057 !*** ./node_modules/core-js/internals/set-species.js ***! 6058 \*******************************************************/ 6059/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6060 6061"use strict"; 6062 6063var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ 73626); 6064var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ 52975); 6065var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 6066var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ 47012); 6067 6068var SPECIES = wellKnownSymbol('species'); 6069 6070module.exports = function (CONSTRUCTOR_NAME) { 6071 var Constructor = getBuiltIn(CONSTRUCTOR_NAME); 6072 var defineProperty = definePropertyModule.f; 6073 6074 if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { 6075 defineProperty(Constructor, SPECIES, { 6076 configurable: true, 6077 get: function () { return this; } 6078 }); 6079 } 6080}; 6081 6082 6083/***/ }), 6084 6085/***/ 58242: 6086/*!*************************************************************!*\ 6087 !*** ./node_modules/core-js/internals/set-to-string-tag.js ***! 6088 \*************************************************************/ 6089/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6090 6091var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ 52975).f; 6092var has = __webpack_require__(/*! ../internals/has */ 67791); 6093var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 6094 6095var TO_STRING_TAG = wellKnownSymbol('toStringTag'); 6096 6097module.exports = function (it, TAG, STATIC) { 6098 if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { 6099 defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); 6100 } 6101}; 6102 6103 6104/***/ }), 6105 6106/***/ 42650: 6107/*!******************************************************!*\ 6108 !*** ./node_modules/core-js/internals/shared-key.js ***! 6109 \******************************************************/ 6110/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6111 6112var shared = __webpack_require__(/*! ../internals/shared */ 77719); 6113var uid = __webpack_require__(/*! ../internals/uid */ 94295); 6114 6115var keys = shared('keys'); 6116 6117module.exports = function (key) { 6118 return keys[key] || (keys[key] = uid(key)); 6119}; 6120 6121 6122/***/ }), 6123 6124/***/ 59941: 6125/*!********************************************************!*\ 6126 !*** ./node_modules/core-js/internals/shared-store.js ***! 6127 \********************************************************/ 6128/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6129 6130var global = __webpack_require__(/*! ../internals/global */ 31864); 6131var setGlobal = __webpack_require__(/*! ../internals/set-global */ 22341); 6132 6133var SHARED = '__core-js_shared__'; 6134var store = global[SHARED] || setGlobal(SHARED, {}); 6135 6136module.exports = store; 6137 6138 6139/***/ }), 6140 6141/***/ 77719: 6142/*!**************************************************!*\ 6143 !*** ./node_modules/core-js/internals/shared.js ***! 6144 \**************************************************/ 6145/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6146 6147var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ 97515); 6148var store = __webpack_require__(/*! ../internals/shared-store */ 59941); 6149 6150(module.exports = function (key, value) { 6151 return store[key] || (store[key] = value !== undefined ? value : {}); 6152})('versions', []).push({ 6153 version: '3.12.0', 6154 mode: IS_PURE ? 'pure' : 'global', 6155 copyright: '© 2021 Denis Pushkarev (zloirock.ru)' 6156}); 6157 6158 6159/***/ }), 6160 6161/***/ 20222: 6162/*!*************************************************************!*\ 6163 !*** ./node_modules/core-js/internals/to-absolute-index.js ***! 6164 \*************************************************************/ 6165/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6166 6167var toInteger = __webpack_require__(/*! ../internals/to-integer */ 59463); 6168 6169var max = Math.max; 6170var min = Math.min; 6171 6172// Helper for a popular repeating case of the spec: 6173// Let integer be ? ToInteger(index). 6174// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). 6175module.exports = function (index, length) { 6176 var integer = toInteger(index); 6177 return integer < 0 ? max(integer + length, 0) : min(integer, length); 6178}; 6179 6180 6181/***/ }), 6182 6183/***/ 8643: 6184/*!*************************************************************!*\ 6185 !*** ./node_modules/core-js/internals/to-indexed-object.js ***! 6186 \*************************************************************/ 6187/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6188 6189// toObject with fallback for non-array-like ES3 strings 6190var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ 56169); 6191var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ 95025); 6192 6193module.exports = function (it) { 6194 return IndexedObject(requireObjectCoercible(it)); 6195}; 6196 6197 6198/***/ }), 6199 6200/***/ 59463: 6201/*!******************************************************!*\ 6202 !*** ./node_modules/core-js/internals/to-integer.js ***! 6203 \******************************************************/ 6204/***/ ((module) => { 6205 6206var ceil = Math.ceil; 6207var floor = Math.floor; 6208 6209// `ToInteger` abstract operation 6210// https://tc39.es/ecma262/#sec-tointeger 6211module.exports = function (argument) { 6212 return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); 6213}; 6214 6215 6216/***/ }), 6217 6218/***/ 15902: 6219/*!*****************************************************!*\ 6220 !*** ./node_modules/core-js/internals/to-length.js ***! 6221 \*****************************************************/ 6222/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6223 6224var toInteger = __webpack_require__(/*! ../internals/to-integer */ 59463); 6225 6226var min = Math.min; 6227 6228// `ToLength` abstract operation 6229// https://tc39.es/ecma262/#sec-tolength 6230module.exports = function (argument) { 6231 return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 6232}; 6233 6234 6235/***/ }), 6236 6237/***/ 16174: 6238/*!*****************************************************!*\ 6239 !*** ./node_modules/core-js/internals/to-object.js ***! 6240 \*****************************************************/ 6241/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6242 6243var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ 95025); 6244 6245// `ToObject` abstract operation 6246// https://tc39.es/ecma262/#sec-toobject 6247module.exports = function (argument) { 6248 return Object(requireObjectCoercible(argument)); 6249}; 6250 6251 6252/***/ }), 6253 6254/***/ 28495: 6255/*!********************************************************!*\ 6256 !*** ./node_modules/core-js/internals/to-primitive.js ***! 6257 \********************************************************/ 6258/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6259 6260var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 6261 6262// `ToPrimitive` abstract operation 6263// https://tc39.es/ecma262/#sec-toprimitive 6264// instead of the ES6 spec version, we didn't implement @@toPrimitive case 6265// and the second argument - flag - preferred type is a string 6266module.exports = function (input, PREFERRED_STRING) { 6267 if (!isObject(input)) return input; 6268 var fn, val; 6269 if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; 6270 if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val; 6271 if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; 6272 throw TypeError("Can't convert object to primitive value"); 6273}; 6274 6275 6276/***/ }), 6277 6278/***/ 72900: 6279/*!*****************************************************************!*\ 6280 !*** ./node_modules/core-js/internals/to-string-tag-support.js ***! 6281 \*****************************************************************/ 6282/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6283 6284var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ 84563); 6285 6286var TO_STRING_TAG = wellKnownSymbol('toStringTag'); 6287var test = {}; 6288 6289test[TO_STRING_TAG] = 'z'; 6290 6291module.exports = String(test) === '[object z]'; 6292 6293 6294/***/ }), 6295 6296/***/ 94295: 6297/*!***********************************************!*\ 6298 !*** ./node_modules/core-js/internals/uid.js ***! 6299 \***********************************************/ 6300/***/ ((module) => { 6301 6302var id = 0; 6303var postfix = Math.random(); 6304 6305module.exports = function (key) { 6306 return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36); 6307}; 6308 6309 6310/***/ }), 6311 6312/***/ 24431: 6313/*!*************************************************************!*\ 6314 !*** ./node_modules/core-js/internals/use-symbol-as-uid.js ***! 6315 \*************************************************************/ 6316/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6317 6318/* eslint-disable es/no-symbol -- required for testing */ 6319var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/native-symbol */ 77040); 6320 6321module.exports = NATIVE_SYMBOL 6322 && !Symbol.sham 6323 && typeof Symbol.iterator == 'symbol'; 6324 6325 6326/***/ }), 6327 6328/***/ 84563: 6329/*!*************************************************************!*\ 6330 !*** ./node_modules/core-js/internals/well-known-symbol.js ***! 6331 \*************************************************************/ 6332/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6333 6334var global = __webpack_require__(/*! ../internals/global */ 31864); 6335var shared = __webpack_require__(/*! ../internals/shared */ 77719); 6336var has = __webpack_require__(/*! ../internals/has */ 67791); 6337var uid = __webpack_require__(/*! ../internals/uid */ 94295); 6338var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/native-symbol */ 77040); 6339var USE_SYMBOL_AS_UID = __webpack_require__(/*! ../internals/use-symbol-as-uid */ 24431); 6340
6341var WellKnownSymbolsStore = shared('wks'); 6342var Symbol = global.Symbol; 6343var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid; 6344 6345module.exports = function (name) { 6346 if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) { 6347 if (NATIVE_SYMBOL && has(Symbol, name)) { 6348 WellKnownSymbolsStore[name] = Symbol[name]; 6349 } else { 6350 WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name); 6351 } 6352 } return WellKnownSymbolsStore[name]; 6353}; 6354 6355 6356/***/ }), 6357 6358/***/ 88854: 6359/*!************************************************!*\ 6360 !*** ./node_modules/core-js/modules/es.map.js ***! 6361 \************************************************/ 6362/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6363 6364"use strict"; 6365 6366var collection = __webpack_require__(/*! ../internals/collection */ 41603); 6367var collectionStrong = __webpack_require__(/*! ../internals/collection-strong */ 5692); 6368 6369// `Map` constructor 6370// https://tc39.es/ecma262/#sec-map-objects 6371module.exports = collection('Map', function (init) { 6372 return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; 6373}, collectionStrong); 6374 6375 6376/***/ }), 6377 6378/***/ 43014: 6379/*!************************************************!*\ 6380 !*** ./node_modules/core-js/modules/es.set.js ***! 6381 \************************************************/ 6382/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6383 6384"use strict"; 6385 6386var collection = __webpack_require__(/*! ../internals/collection */ 41603); 6387var collectionStrong = __webpack_require__(/*! ../internals/collection-strong */ 5692); 6388 6389// `Set` constructor 6390// https://tc39.es/ecma262/#sec-set-objects 6391module.exports = collection('Set', function (init) { 6392 return function Set() { return init(this, arguments.length ? arguments[0] : undefined); }; 6393}, collectionStrong); 6394 6395 6396/***/ }), 6397 6398/***/ 63438: 6399/*!*****************************************************!*\ 6400 !*** ./node_modules/core-js/modules/es.weak-map.js ***! 6401 \*****************************************************/ 6402/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6403 6404"use strict"; 6405 6406var global = __webpack_require__(/*! ../internals/global */ 31864); 6407var redefineAll = __webpack_require__(/*! ../internals/redefine-all */ 78715); 6408var InternalMetadataModule = __webpack_require__(/*! ../internals/internal-metadata */ 64238); 6409var collection = __webpack_require__(/*! ../internals/collection */ 41603); 6410var collectionWeak = __webpack_require__(/*! ../internals/collection-weak */ 96491); 6411var isObject = __webpack_require__(/*! ../internals/is-object */ 60726); 6412var enforceIternalState = __webpack_require__(/*! ../internals/internal-state */ 52493).enforce; 6413var NATIVE_WEAK_MAP = __webpack_require__(/*! ../internals/native-weak-map */ 51635); 6414 6415var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global; 6416// eslint-disable-next-line es/no-object-isextensible -- safe 6417var isExtensible = Object.isExtensible; 6418var InternalWeakMap; 6419 6420var wrapper = function (init) { 6421 return function WeakMap() { 6422 return init(this, arguments.length ? arguments[0] : undefined); 6423 }; 6424}; 6425 6426// `WeakMap` constructor 6427// https://tc39.es/ecma262/#sec-weakmap-constructor 6428var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak); 6429 6430// IE11 WeakMap frozen keys fix 6431// We can't use feature detection because it crash some old IE builds 6432// https://github.com/zloirock/core-js/issues/485 6433if (NATIVE_WEAK_MAP && IS_IE11) { 6434 InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); 6435 InternalMetadataModule.REQUIRED = true; 6436 var WeakMapPrototype = $WeakMap.prototype; 6437 var nativeDelete = WeakMapPrototype['delete']; 6438 var nativeHas = WeakMapPrototype.has; 6439 var nativeGet = WeakMapPrototype.get; 6440 var nativeSet = WeakMapPrototype.set; 6441 redefineAll(WeakMapPrototype, { 6442 'delete': function (key) { 6443 if (isObject(key) && !isExtensible(key)) { 6444 var state = enforceIternalState(this); 6445 if (!state.frozen) state.frozen = new InternalWeakMap(); 6446 return nativeDelete.call(this, key) || state.frozen['delete'](key); 6447 } return nativeDelete.call(this, key); 6448 }, 6449 has: function has(key) { 6450 if (isObject(key) && !isExtensible(key)) { 6451 var state = enforceIternalState(this); 6452 if (!state.frozen) state.frozen = new InternalWeakMap(); 6453 return nativeHas.call(this, key) || state.frozen.has(key); 6454 } return nativeHas.call(this, key); 6455 }, 6456 get: function get(key) { 6457 if (isObject(key) && !isExtensible(key)) { 6458 var state = enforceIternalState(this); 6459 if (!state.frozen) state.frozen = new InternalWeakMap(); 6460 return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); 6461 } return nativeGet.call(this, key); 6462 }, 6463 set: function set(key, value) { 6464 if (isObject(key) && !isExtensible(key)) { 6465 var state = enforceIternalState(this); 6466 if (!state.frozen) state.frozen = new InternalWeakMap(); 6467 nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); 6468 } else nativeSet.call(this, key, value); 6469 return this; 6470 } 6471 }); 6472} 6473 6474 6475/***/ }), 6476 6477/***/ 37935: 6478/*!************************************************************************!*\ 6479 !*** ./node_modules/core-js/modules/esnext.reflect.define-metadata.js ***! 6480 \************************************************************************/ 6481/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6482 6483var $ = __webpack_require__(/*! ../internals/export */ 51163); 6484var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6485var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6486 6487var toMetadataKey = ReflectMetadataModule.toKey; 6488var ordinaryDefineOwnMetadata = ReflectMetadataModule.set; 6489 6490// `Reflect.defineMetadata` method 6491// https://github.com/rbuckton/reflect-metadata 6492$({ target: 'Reflect', stat: true }, {
vendor: 4,698 bytes, lines 6493-6600
6493 defineMetadata: function defineMetadata(metadataKey, metadataValue, target /* , targetKey */) { 6494 var targetKey = arguments.length < 4 ? undefined : toMetadataKey(arguments[3]); 6495 ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), targetKey); 6496 } 6497}); 6498 6499 6500/***/ }), 6501 6502/***/ 13199: 6503/*!************************************************************************!*\ 6504 !*** ./node_modules/core-js/modules/esnext.reflect.delete-metadata.js ***! 6505 \************************************************************************/ 6506/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6507 6508var $ = __webpack_require__(/*! ../internals/export */ 51163); 6509var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6510var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6511 6512var toMetadataKey = ReflectMetadataModule.toKey; 6513var getOrCreateMetadataMap = ReflectMetadataModule.getMap; 6514var store = ReflectMetadataModule.store; 6515 6516// `Reflect.deleteMetadata` method 6517// https://github.com/rbuckton/reflect-metadata 6518$({ target: 'Reflect', stat: true }, { 6519 deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) { 6520 var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); 6521 var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false); 6522 if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false; 6523 if (metadataMap.size) return true; 6524 var targetMetadata = store.get(target); 6525 targetMetadata['delete'](targetKey); 6526 return !!targetMetadata.size || store['delete'](target); 6527 } 6528}); 6529 6530 6531/***/ }), 6532 6533/***/ 11304: 6534/*!**************************************************************************!*\ 6535 !*** ./node_modules/core-js/modules/esnext.reflect.get-metadata-keys.js ***! 6536 \**************************************************************************/ 6537/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6538 6539var $ = __webpack_require__(/*! ../internals/export */ 51163); 6540// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` 6541var Set = __webpack_require__(/*! ../modules/es.set */ 43014); 6542var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6543var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6544var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ 3963); 6545var iterate = __webpack_require__(/*! ../internals/iterate */ 53284); 6546 6547var ordinaryOwnMetadataKeys = ReflectMetadataModule.keys; 6548var toMetadataKey = ReflectMetadataModule.toKey; 6549 6550var from = function (iter) { 6551 var result = []; 6552 iterate(iter, result.push, { that: result }); 6553 return result; 6554}; 6555 6556var ordinaryMetadataKeys = function (O, P) { 6557 var oKeys = ordinaryOwnMetadataKeys(O, P); 6558 var parent = getPrototypeOf(O); 6559 if (parent === null) return oKeys; 6560 var pKeys = ordinaryMetadataKeys(parent, P); 6561 return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys; 6562}; 6563 6564// `Reflect.getMetadataKeys` method 6565// https://github.com/rbuckton/reflect-metadata 6566$({ target: 'Reflect', stat: true }, { 6567 getMetadataKeys: function getMetadataKeys(target /* , targetKey */) { 6568 var targetKey = arguments.length < 2 ? undefined : toMetadataKey(arguments[1]); 6569 return ordinaryMetadataKeys(anObject(target), targetKey); 6570 } 6571}); 6572 6573 6574/***/ }), 6575 6576/***/ 47545: 6577/*!*********************************************************************!*\ 6578 !*** ./node_modules/core-js/modules/esnext.reflect.get-metadata.js ***! 6579 \*********************************************************************/ 6580/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6581 6582var $ = __webpack_require__(/*! ../internals/export */ 51163); 6583var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6584var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6585var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ 3963); 6586 6587var ordinaryHasOwnMetadata = ReflectMetadataModule.has; 6588var ordinaryGetOwnMetadata = ReflectMetadataModule.get; 6589var toMetadataKey = ReflectMetadataModule.toKey; 6590 6591var ordinaryGetMetadata = function (MetadataKey, O, P) { 6592 var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P); 6593 if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P); 6594 var parent = getPrototypeOf(O); 6595 return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined; 6596}; 6597 6598// `Reflect.getMetadata` method 6599// https://github.com/rbuckton/reflect-metadata 6600$({ target: 'Reflect', stat: true }, {
vendor: 4,554 bytes, lines 6601-6708
6601 getMetadata: function getMetadata(metadataKey, target /* , targetKey */) { 6602 var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); 6603 return ordinaryGetMetadata(metadataKey, anObject(target), targetKey); 6604 } 6605}); 6606 6607 6608/***/ }), 6609 6610/***/ 87067: 6611/*!******************************************************************************!*\ 6612 !*** ./node_modules/core-js/modules/esnext.reflect.get-own-metadata-keys.js ***! 6613 \******************************************************************************/ 6614/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6615 6616var $ = __webpack_require__(/*! ../internals/export */ 51163); 6617var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6618var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6619 6620var ordinaryOwnMetadataKeys = ReflectMetadataModule.keys; 6621var toMetadataKey = ReflectMetadataModule.toKey; 6622 6623// `Reflect.getOwnMetadataKeys` method 6624// https://github.com/rbuckton/reflect-metadata 6625$({ target: 'Reflect', stat: true }, { 6626 getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) { 6627 var targetKey = arguments.length < 2 ? undefined : toMetadataKey(arguments[1]); 6628 return ordinaryOwnMetadataKeys(anObject(target), targetKey); 6629 } 6630}); 6631 6632 6633/***/ }), 6634 6635/***/ 40110: 6636/*!*************************************************************************!*\ 6637 !*** ./node_modules/core-js/modules/esnext.reflect.get-own-metadata.js ***! 6638 \*************************************************************************/ 6639/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6640 6641var $ = __webpack_require__(/*! ../internals/export */ 51163); 6642var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6643var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6644 6645var ordinaryGetOwnMetadata = ReflectMetadataModule.get; 6646var toMetadataKey = ReflectMetadataModule.toKey; 6647 6648// `Reflect.getOwnMetadata` method 6649// https://github.com/rbuckton/reflect-metadata 6650$({ target: 'Reflect', stat: true }, { 6651 getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) { 6652 var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); 6653 return ordinaryGetOwnMetadata(metadataKey, anObject(target), targetKey); 6654 } 6655}); 6656 6657 6658/***/ }), 6659 6660/***/ 78527: 6661/*!*********************************************************************!*\ 6662 !*** ./node_modules/core-js/modules/esnext.reflect.has-metadata.js ***! 6663 \*********************************************************************/ 6664/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6665 6666var $ = __webpack_require__(/*! ../internals/export */ 51163); 6667var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6668var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6669var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ 3963); 6670 6671var ordinaryHasOwnMetadata = ReflectMetadataModule.has; 6672var toMetadataKey = ReflectMetadataModule.toKey; 6673 6674var ordinaryHasMetadata = function (MetadataKey, O, P) { 6675 var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P); 6676 if (hasOwn) return true; 6677 var parent = getPrototypeOf(O); 6678 return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false; 6679}; 6680 6681// `Reflect.hasMetadata` method 6682// https://github.com/rbuckton/reflect-metadata 6683$({ target: 'Reflect', stat: true }, { 6684 hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) { 6685 var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); 6686 return ordinaryHasMetadata(metadataKey, anObject(target), targetKey); 6687 } 6688}); 6689 6690 6691/***/ }), 6692 6693/***/ 3166: 6694/*!*************************************************************************!*\ 6695 !*** ./node_modules/core-js/modules/esnext.reflect.has-own-metadata.js ***! 6696 \*************************************************************************/ 6697/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6698 6699var $ = __webpack_require__(/*! ../internals/export */ 51163); 6700var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6701var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6702 6703var ordinaryHasOwnMetadata = ReflectMetadataModule.has; 6704var toMetadataKey = ReflectMetadataModule.toKey; 6705 6706// `Reflect.hasOwnMetadata` method 6707// https://github.com/rbuckton/reflect-metadata 6708$({ target: 'Reflect', stat: true }, {
6709 hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) { 6710 var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); 6711 return ordinaryHasOwnMetadata(metadataKey, anObject(target), targetKey); 6712 } 6713}); 6714 6715 6716/***/ }), 6717 6718/***/ 5551: 6719/*!*****************************************************************!*\ 6720 !*** ./node_modules/core-js/modules/esnext.reflect.metadata.js ***! 6721 \*****************************************************************/ 6722/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6723 6724var $ = __webpack_require__(/*! ../internals/export */ 51163); 6725var ReflectMetadataModule = __webpack_require__(/*! ../internals/reflect-metadata */ 54230); 6726var anObject = __webpack_require__(/*! ../internals/an-object */ 21099); 6727 6728var toMetadataKey = ReflectMetadataModule.toKey; 6729var ordinaryDefineOwnMetadata = ReflectMetadataModule.set; 6730 6731// `Reflect.metadata` method 6732// https://github.com/rbuckton/reflect-metadata 6733$({ target: 'Reflect', stat: true }, { 6734 metadata: function metadata(metadataKey, metadataValue) { 6735 return function decorator(target, key) { 6736 ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetadataKey(key)); 6737 }; 6738 } 6739}); 6740 6741 6742/***/ }), 6743 6744/***/ 17168: 6745/*!************************************************************!*\ 6746 !*** ./node_modules/core-js/proposals/reflect-metadata.js ***! 6747 \************************************************************/ 6748/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 6749 6750__webpack_require__(/*! ../modules/esnext.reflect.define-metadata */ 37935); 6751__webpack_require__(/*! ../modules/esnext.reflect.delete-metadata */ 13199); 6752__webpack_require__(/*! ../modules/esnext.reflect.get-metadata */ 47545); 6753__webpack_require__(/*! ../modules/esnext.reflect.get-metadata-keys */ 11304); 6754__webpack_require__(/*! ../modules/esnext.reflect.get-own-metadata */ 40110); 6755__webpack_require__(/*! ../modules/esnext.reflect.get-own-metadata-keys */ 87067); 6756__webpack_require__(/*! ../modules/esnext.reflect.has-metadata */ 78527); 6757__webpack_require__(/*! ../modules/esnext.reflect.has-own-metadata */ 3166); 6758__webpack_require__(/*! ../modules/esnext.reflect.metadata */ 5551); 6759 6760 6761/***/ }) 6762 6763}, 6764/******/ __webpack_require__ => { // webpackRuntimeModules 6765/******/ "use strict"; 6766/******/ 6767/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId)) 6768/******/ var __webpack_exports__ = (__webpack_exec__(7435), __webpack_exec__(12626)); 6769/******/ } 6770]); 6771//# sourceMappingURL=polyfills.js.map
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.