vendor: 3,603 bytes, lines 1-89
1/******/ (function(modules) { // webpackBootstrap 2/******/ // The module cache 3/******/ var installedModules = {}; 4/******/ 5/******/ // The require function 6/******/ function __webpack_require__(moduleId) { 7/******/ 8/******/ // Check if module is in cache 9/******/ if(installedModules[moduleId]) { 10/******/ return installedModules[moduleId].exports; 11/******/ } 12/******/ // Create a new module (and put it into the cache) 13/******/ var module = installedModules[moduleId] = { 14/******/ i: moduleId, 15/******/ l: false, 16/******/ exports: {} 17/******/ }; 18/******/ 19/******/ // Execute the module function 20/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 21/******/ 22/******/ // Flag the module as loaded 23/******/ module.l = true; 24/******/ 25/******/ // Return the exports of the module 26/******/ return module.exports; 27/******/ } 28/******/ 29/******/ 30/******/ // expose the modules object (__webpack_modules__) 31/******/ __webpack_require__.m = modules; 32/******/ 33/******/ // expose the module cache 34/******/ __webpack_require__.c = installedModules; 35/******/ 36/******/ // define getter function for harmony exports 37/******/ __webpack_require__.d = function(exports, name, getter) { 38/******/ if(!__webpack_require__.o(exports, name)) { 39/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 40/******/ } 41/******/ }; 42/******/ 43/******/ // define __esModule on exports 44/******/ __webpack_require__.r = function(exports) { 45/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 46/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 47/******/ } 48/******/ Object.defineProperty(exports, '__esModule', { value: true }); 49/******/ }; 50/******/ 51/******/ // create a fake namespace object 52/******/ // mode & 1: value is a module id, require it 53/******/ // mode & 2: merge all properties of value into the ns 54/******/ // mode & 4: return value when already ns object 55/******/ // mode & 8|1: behave like require 56/******/ __webpack_require__.t = function(value, mode) { 57/******/ if(mode & 1) value = __webpack_require__(value); 58/******/ if(mode & 8) return value; 59/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 60/******/ var ns = Object.create(null); 61/******/ __webpack_require__.r(ns); 62/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 63/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 64/******/ return ns; 65/******/ }; 66/******/ 67/******/ // getDefaultExport function for compatibility with non-harmony modules 68/******/ __webpack_require__.n = function(module) { 69/******/ var getter = module && module.__esModule ? 70/******/ function getDefault() { return module['default']; } : 71/******/ function getModuleExports() { return module; }; 72/******/ __webpack_require__.d(getter, 'a', getter); 73/******/ return getter; 74/******/ }; 75/******/ 76/******/ // Object.prototype.hasOwnProperty.call 77/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 78/******/ 79/******/ // __webpack_public_path__ 80/******/ __webpack_require__.p = ""; 81/******/ 82/******/ 83/******/ // Load entry module and return exports 84/******/ return __webpack_require__(__webpack_require__.s = 0); 85/******/ }) 86/************************************************************************/ 87/******/ ({ 88 89/***/ "./
89js/scripts_es6.js": 90/*!***************************!*\ 91 !*** ./js/scripts_es6.js ***! 92 \***************************/ 93/*! no exports provided */ 94/***/ (function(module, __webpack_exports__, __webpack_require__) { 95 96"use strict"; 97__webpack_require__.r(__webpack_exports__); 98/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "./node_modules/@babel/runtime/helpers/toConsumableArray.js"); 99/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0__); 100/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/slicedToArray */ "./node_modules/@babel/runtime/helpers/slicedToArray.js"); 101/* harmony import */ var _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1__); 102/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/defineProperty.js"); 103/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__); 104/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/regenerator */ "./node_modules/@babel/runtime/regenerator/index.js"); 105/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3__); 106/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "./node_modules/@babel/runtime/helpers/asyncToGenerator.js"); 107/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_4__); 108 109 110 111 112 113 114 115 116function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 117 118function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 119 120var cf7signature_resized = 0; // for compatibility with contact-form-7-signature-addon 121 122var wpcf7cf_timeout; 123var wpcf7cf_change_time_ms = 100; 124 125if (window.wpcf7 && !wpcf7.setStatus) { 126 wpcf7.setStatus = function (form, status) { 127 form = form.length ? form[0] : form; // if form is a jQuery object, only grab te html-element 128 129 var defaultStatuses = new Map([// 0: Status in API response, 1: Status in HTML class 130 ['init', 'init'], ['validation_failed', 'invalid'], ['acceptance_missing', 'unaccepted'], ['spam', 'spam'], ['aborted', 'aborted'], ['mail_sent', 'sent'], ['mail_failed', 'failed'], ['submitting', 'submitting'], ['resetting', 'resetting']]); 131 132 if (defaultStatuses.has(status)) { 133 status = defaultStatuses.get(status); 134 } 135 136 if (!Array.from(defaultStatuses.values()).includes(status)) { 137 status = status.replace(/[^0-9a-z]+/i, ' ').trim(); 138 status = status.replace(/\s+/, '-'); 139 status = "custom-".concat(status); 140 } 141 142 var prevStatus = form.getAttribute('data-status'); 143 form.wpcf7.status = status; 144 form.setAttribute('data-status', status); 145 form.classList.add(status); 146 147 if (prevStatus && prevStatus !== status) { 148 form.classList.remove(prevStatus); 149 } 150 151 return status; 152 }; 153} 154 155if (window.wpcf7cf_running_tests) { 156 jQuery('input[name="_wpcf7cf_options"]').each(function (e) { 157 var $input = jQuery(this); 158 var opt = JSON.parse($input.val()); 159 opt.settings.animation_intime = 0;
160 opt.settings.animation_outtime = 0; 161 $input.val(JSON.stringify(opt)); 162 }); 163 wpcf7cf_change_time_ms = 0; 164} 165 166var wpcf7cf_show_animation = { 167 "height": "show", 168 "marginTop": "show", 169 "marginBottom": "show", 170 "paddingTop": "show", 171 "paddingBottom": "show" 172}; 173var wpcf7cf_hide_animation = { 174 "height": "hide", 175 "marginTop": "hide", 176 "marginBottom": "hide", 177 "paddingTop": "hide", 178 "paddingBottom": "hide" 179}; 180var wpcf7cf_show_step_animation = { 181 "opacity": "show" 182}; 183var wpcf7cf_hide_step_animation = { 184 "opacity": "hide" 185}; 186var wpcf7cf_change_events = 'input.wpcf7cf paste.wpcf7cf change.wpcf7cf click.wpcf7cf propertychange.wpcf7cf'; 187var wpcf7cf_forms = []; 188window.wpcf7cf_dom = {}; 189 190var wpcf7cf_reload_dom = function wpcf7cf_reload_dom($form) { 191 wpcf7cf_dom = wpcf7cf.get_simplified_dom_model($form[0]); 192}; 193 194var wpcf7cf_getFieldsByOriginalName = function wpcf7cf_getFieldsByOriginalName(originalName) { 195 return Object.values(wpcf7cf_dom).filter(function (inputField) { 196 return inputField.original_name === originalName || inputField.original_name === originalName + '[]'; 197 }); 198}; 199 200var wpcf7cf_getFieldByName = function wpcf7cf_getFieldByName(name) { 201 return wpcf7cf_dom[name] || wpcf7cf_dom[name + '[]']; 202}; // endsWith polyfill 203 204 205if (!String.prototype.endsWith) { 206 String.prototype.endsWith = function (search, this_len) { 207 if (this_len === undefined || this_len > this.length) { 208 this_len = this.length; 209 } 210 211 return this.substring(this_len - search.length, this_len) === search; 212 }; 213} // Object.values polyfill 214 215 216if (!Object.values) Object.values = function (o) { 217 return Object.keys(o).map(function (k) { 218 return o[k]; 219 }); 220}; // Array.from polyfill 221 222if (!Array.from) { 223 Array.from = function () { 224 var toStr = Object.prototype.toString; 225 226 var isCallable = function isCallable(fn) { 227 return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; 228 }; 229 230 var toInteger = function toInteger(value) { 231 var number = Number(value); 232 233 if (isNaN(number)) { 234 return 0; 235 } 236 237 if (number === 0 || !isFinite(number)) { 238 return number; 239 } 240 241 return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); 242 }; 243 244 var maxSafeInteger = Math.pow(2, 53) - 1; 245 246 var toLength = function toLength(value) { 247 var len = toInteger(value); 248 return Math.min(Math.max(len, 0), maxSafeInteger); 249 }; // The length property of the from method is 1. 250 251 252 return function from(arrayLike 253 /*, mapFn, thisArg */ 254 ) { 255 // 1. Let C be the this value. 256 var C = this; // 2. Let items be ToObject(arrayLike). 257 258 var items = Object(arrayLike); // 3. ReturnIfAbrupt(items). 259 260 if (arrayLike == null) { 261 throw new TypeError("Array.from requires an array-like object - not null or undefined"); 262 } // 4. If mapfn is undefined, then let mapping be false. 263 264 265 var mapFn = arguments.length > 1 ? arguments[1] : void undefined; 266 var T; 267 268 if (typeof mapFn !== 'undefined') { 269 // 5. else 270 // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. 271 if (!isCallable(mapFn)) { 272 throw new TypeError('Array.from: when provided, the second argument must be a function'); 273 } // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. 274 275 276 if (arguments.length > 2) { 277 T = arguments[2]; 278 } 279 } // 10. Let lenValue be Get(items, "length"). 280 // 11. Let len be ToLength(lenValue). 281 282 283 var len = toLength(items.length); // 13. If IsConstructor(C) is true, then 284 // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len. 285 // 14. a. Else, Let A be ArrayCreate(len). 286 287 var A = isCallable(C) ? Object(new C(len)) : new Array(len); // 16. Let k be 0. 288 289 var k = 0; // 17. Repeat, while k < len⦠(also steps a - h) 290 291 var kValue; 292 293 while (k < len) { 294 kValue = items[k]; 295 296 if (mapFn) { 297 A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); 298 } else { 299 A[k] = kValue; 300 } 301 302 k += 1; 303 } // 18. Let putStatus be Put(A, "length", len, true). 304 305 306 A.length = len; // 20. Return A. 307 308 return A; 309 }; 310 }(); 311} 312 313var Wpcf7cfForm = function Wpcf7cfForm($form) { 314 var options_element = $form.find('input[name="_wpcf7cf_options"]').eq(0); 315 316 if (!options_element.length || !options_element.val()) { 317 // doesn't look like a CF7 form created with conditional fields plugin enabled. 318 return false;
319 } 320 321 var form = this; 322 var form_options = JSON.parse(options_element.val()); 323 form.$form = $form; 324 form.$input_hidden_group_fields = $form.find('[name="_wpcf7cf_hidden_group_fields"]'); 325 form.$input_hidden_groups = $form.find('[name="_wpcf7cf_hidden_groups"]'); 326 form.$input_visible_groups = $form.find('[name="_wpcf7cf_visible_groups"]'); 327 form.$input_repeaters = $form.find('[name="_wpcf7cf_repeaters"]'); 328 form.$input_steps = $form.find('[name="_wpcf7cf_steps"]'); 329 form.unit_tag = $form.closest('.wpcf7').attr('id'); 330 form.conditions = form_options['conditions']; // Wrapper around jQuery(selector, form.$form) 331 332 form.get = function (selector) { 333 // TODO: implement some caching here. 334 return jQuery(selector, form.$form); 335 }; // compatibility with conditional forms created with older versions of the plugin ( < 1.4 ) 336 337 338 for (var i = 0; i < form.conditions.length; i++) { 339 var condition = form.conditions[i]; 340 341 if (!('and_rules' in condition)) { 342 condition.and_rules = [{ 343 'if_field': condition.if_field, 344 'if_value': condition.if_value, 345 'operator': condition.operator 346 }]; 347 } 348 } 349 350 form.initial_conditions = form.conditions; 351 form.settings = form_options['settings']; 352 form.$groups = jQuery(); // empty jQuery set 353 354 form.repeaters = []; 355 form.multistep = null; 356 form.fields = []; 357 form.settings.animation_intime = parseInt(form.settings.animation_intime); 358 form.settings.animation_outtime = parseInt(form.settings.animation_outtime); 359 360 if (form.settings.animation === 'no') { 361 form.settings.animation_intime = 0; 362 form.settings.animation_outtime = 0; 363 } 364 365 form.updateGroups(); 366 form.updateEventListeners(); 367 form.displayFields(); // bring form in initial state if the reset event is fired on it. 368 369 form.$form.on('reset.wpcf7cf', form, function (e) { 370 var form = e.data; 371 setTimeout(function () { 372 form.displayFields(); 373 form.resetRepeaters(); 374 375 if (form.multistep != null) { 376 form.multistep.moveToStep(1); 377 } 378 }, 200); 379 }); // PRO ONLY 380 381 form.get('.wpcf7cf_repeater:not(.wpcf7cf_repeater .wpcf7cf_repeater)').each(function () { 382 form.repeaters.push(new Wpcf7cfRepeater(jQuery(this), form)); 383 }); 384 form.$input_repeaters.val(JSON.stringify(form.repeaters.map(function (item) { 385 return item.params.$repeater.id; 386 }))); 387 var $multistep = form.get('.wpcf7cf_multistep'); 388 389 if ($multistep.length) { 390 form.multistep = new Wpcf7cfMultistep($multistep, form); // window.wpcf7cf.updateMultistepState(form.multistep); 391 } // END PRO ONLY 392 393}; 394/** 395 * reset initial number of subs for each repeater. 396 * (does not clear values) 397 */ 398 399 400Wpcf7cfForm.prototype.resetRepeaters = function () { 401 var form = this; 402 form.repeaters.forEach(function (repeater) { 403 repeater.updateSubs(repeater.params.$repeater.initial_subs); 404 }); 405}; 406 407Wpcf7cfForm.prototype.displayFields = function () { 408 var form = this; 409 var wpcf7cf_conditions = this.conditions; 410 var wpcf7cf_settings = this.settings; //for compatibility with contact-form-7-signature-addon 411 412 if (cf7signature_resized === 0 && typeof signatures !== 'undefined' && signatures.constructor === Array && signatures.length > 0) { 413 for (var i = 0; i < signatures.length; i++) { 414 if (signatures[i].canvas.width === 0) { 415 var $sig_canvas = jQuery(".wpcf7-form-control-signature-body>canvas"); 416 var $sig_wrap = jQuery(".wpcf7-form-control-signature-wrap"); 417 $sig_canvas.eq(i).attr('width', $sig_wrap.width()); 418 $sig_canvas.eq(i).attr('height', $sig_wrap.height()); 419 cf7signature_resized = 1; 420 } 421 } 422 } 423 424 form.$groups.addClass('wpcf7cf-hidden'); 425 wpcf7cf_reload_dom(form.$form); 426 427 for (var i = 0; i < wpcf7cf_conditions.length; i++) { 428 var condition = wpcf7cf_conditions[i]; 429 var show_group = window.wpcf7cf.should_group_be_shown(condition, form); 430 431 if (show_group) { 432 form.get('[data-id="' + condition.then_field + '"]').removeClass('wpcf7cf-hidden'); 433 } 434 } 435 436 var animation_intime = wpcf7cf_settings.animation_intime;
437 var animation_outtime = wpcf7cf_settings.animation_outtime; 438 form.$groups.each(function (index) { 439 var $group = jQuery(this); 440 441 if ($group.is(':animated')) { 442 $group.finish(); // stop any current animations on the group 443 } 444 445 if ($group.css('display') === 'none' && !$group.hasClass('wpcf7cf-hidden')) { 446 if ($group.prop('tagName') === 'SPAN') { 447 $group.show().trigger('wpcf7cf_show_group'); // show instantly 448 } else { 449 $group.animate(wpcf7cf_show_animation, animation_intime).trigger('wpcf7cf_show_group'); // show with animation 450 } 451 452 if ($group.attr('data-disable_on_hide') !== undefined) { 453 $group.find(':input').prop('disabled', false); 454 } 455 } else if ($group.css('display') !== 'none' && $group.hasClass('wpcf7cf-hidden')) { 456 if ($group.attr('data-clear_on_hide') !== undefined) { 457 var $inputs = jQuery(':input', $group).not(':button, :submit, :reset, :hidden'); 458 $inputs.each(function () { 459 var $this = jQuery(this); 460 $this.val(this.defaultValue); 461 $this.prop('checked', this.defaultChecked); 462 }); 463 jQuery('option', $group).each(function () { 464 this.selected = this.defaultSelected; 465 }); 466 jQuery('select', $group).each(function () { 467 var $select = jQuery(this); 468 469 if ($select.val() === null) { 470 $select.val(jQuery("option:first", $select).val()); 471 } 472 }); 473 $inputs.trigger('change'); 474 } 475 476 if ($group.prop('tagName') === 'SPAN') { 477 $group.hide().trigger('wpcf7cf_hide_group'); 478 } else { 479 $group.animate(wpcf7cf_hide_animation, animation_outtime).trigger('wpcf7cf_hide_group'); // hide 480 } 481 } 482 }); 483 form.updateHiddenFields(); 484 form.updateSummaryFields(); 485}; 486 487Wpcf7cfForm.prototype.updateSummaryFields = function () { 488 var form = this; 489 var $summary = form.get('.wpcf7cf-summary'); 490 if ($summary.length == 0 || !$summary.is(':visible')) return; 491 var fd = new FormData(); 492 var formdata = form.$form.serializeArray(); 493 jQuery.each(formdata, function (key, input) { 494 fd.append(input.name, input.value); 495 }); // Make sure to add file fields to FormData 496 497 jQuery.each(form.$form.find('input[type="file"]'), function (index, el) { 498 if (!el.files.length) return true; // continue 499 500 var fieldName = el.name; 501 fd.append(fieldName, new Blob(), Array.from(el.files).map(function (file) { 502 return file.name; 503 }).join(', ')); 504 }); // add file fields to form-data 505 506 jQuery.ajax({ 507 url: wpcf7cf_global_settings.ajaxurl + '?action=wpcf7cf_get_summary', 508 type: 'POST', 509 data: fd, 510 processData: false, 511 contentType: false, 512 dataType: 'json', 513 success: function success(json) { 514 $summary.html(json.summaryHtml); 515 } 516 }); 517}; 518 519Wpcf7cfForm.prototype.updateHiddenFields = function () { 520 var form = this; 521 var hidden_fields = []; 522 var hidden_groups = []; 523 var visible_groups = []; 524 var disabled_fields = []; 525 form.$groups.each(function () { 526 var $group = jQuery(this); 527 528 if ($group.hasClass('wpcf7cf-hidden')) { 529 hidden_groups.push($group.attr('data-id')); 530 $group.find('input,select,textarea').each(function () { 531 hidden_fields.push(jQuery(this).attr('name')); 532 }); 533 534 if ($group.attr('data-disable_on_hide') !== undefined) { 535 console.log('disabling'); 536 $group.find(':input').prop('disabled', true); 537 } 538 } else { 539 visible_groups.push($group.attr('data-id')); 540 } 541 }); 542 form.hidden_fields = hidden_fields; 543 form.hidden_groups = hidden_groups; 544 form.visible_groups = visible_groups; 545 form.$input_hidden_group_fields.val(JSON.stringify(hidden_fields)); 546 form.$input_hidden_groups.val(JSON.stringify(hidden_groups)); 547 form.$input_visible_groups.val(JSON.stringify(visible_groups)); 548 return true; 549}; 550 551Wpcf7cfForm.prototype.updateGroups = function () { 552 var form = this; 553 form.$groups = form.$form.find('[data-class="wpcf7cf_group"]'); 554 form.$groups.height('auto'); 555 form.conditions = window.wpcf7cf.get_nested_conditions(form.initial_conditions, form.$form); 556}; 557 558Wpcf7cfForm.prototype.updateEventListeners = function () { 559 var form = this; // monitor input changes, and call displayFields() if something has changed 560 561 form.get('input, select, textarea, button').not('.wpcf7cf_add, .wpcf7cf_remove').off(wpcf7cf_change_events).on(wpcf7cf_change_events, form, function (e) { 562 var form = e.data; 563 clearTimeout(wpcf7cf_timeout); 564 wpcf7cf_timeout = setTimeout(function () { 565 form.displayFields(); 566 }, wpcf7cf_change_time_ms); 567 }); // PRO ONLY 568 569 form.get('.wpcf7cf-togglebutton').off('click.toggle_wpcf7cf').on('click.toggle_wpcf7cf', function () { 570 var $this = jQuery(this); 571 572 if ($this.text() === $this.attr('data-val-1')) { 573 $this.text($this.attr('data-val-2')); 574 $this.val($this.attr('data-val-2')); 575 } else { 576 $this.text($this.attr('data-val-1')); 577 $this.val($this.attr('data-val-1')); 578 } 579 }); // END PRO ONLY 580}; // PRO ONLY 581 582 583function Wpcf7cfRepeater($repeater, form) { 584 var $ = jQuery; 585 var repeater = this; 586 var wpcf7cf_settings = form.settings; 587 repeater.form = form; 588 $repeater.parentRepeaters = Array.from($repeater.parents('.wpcf7cf_repeater').map(function () { 589 return this.getAttribute('data-id'); 590 })).reverse(); 591 $repeater.num_subs = 0; 592 $repeater.id = $repeater.attr('data-id'); 593 $repeater.orig_id = $repeater.attr('data-orig_data_id'); 594 $repeater.min = typeof $repeater.attr('data-min') !== 'undefined' ? parseInt($repeater.attr('data-min')) : 1; 595 $repeater.max = typeof $repeater.attr('data-max') !== 'undefined' ? parseInt($repeater.attr('data-max')) : 200; 596 $repeater.initial_subs = typeof $repeater.attr('data-initial') !== 'undefined' ? parseInt($repeater.attr('data-initial')) : $repeater.min; 597 if ($repeater.initial_subs > $repeater.max) $repeater.initial_subs = $repeater.max; 598 var $repeater_sub = $repeater.children('.wpcf7cf_repeater_sub').eq(0); 599 var $repeater_controls = $repeater.children('.wpcf7cf_repeater_controls').eq(0); 600 var $repeater_sub_clone = $repeater_sub.clone(); 601 $repeater_sub_clone.find('.wpcf7cf_repeater_sub').addBack('.wpcf7cf_repeater_sub').each(function () { 602 var $this = jQuery(this); 603 var prev_suffix = $this.attr('data-repeater_sub_suffix'); 604 var new_suffix = prev_suffix + '__{{repeater_sub_suffix}}'; 605 $this.attr('data-repeater_sub_suffix', new_suffix); 606 }); 607 $repeater_sub_clone.find('[name]').each(function () { 608 var $this = jQuery(this); 609 var prev_name = $this.attr('name'); 610 var new_name = repeater.getNewName(prev_name); 611 var orig_name = $this.attr('data-orig_name') != null ? $this.attr('data-orig_name') : prev_name; 612 $this.attr('name', new_name); 613 $this.attr('data-orig_name', orig_name); 614 $this.closest('.wpcf7-form-control-wrap').addClass(new_name.replace('[]', '')); 615 }); 616 $repeater_sub_clone.find('.wpcf7cf_repeater,[data-class="wpcf7cf_group"]').each(function () { 617 var $this = jQuery(this); 618 var prev_data_id = $this.attr('data-id'); 619 var orig_data_id = $this.attr('data-orig_data_id') != null ? $this.attr('data-orig_data_id') : prev_data_id; 620 var new_data_id = repeater.getNewName(prev_data_id); 621 622 if (prev_data_id.endsWith('_count')) { 623 new_data_id = prev_data_id.replace('_count', '__{{repeater_sub_suffix}}_count'); 624 } 625 626 $this.attr('data-id', new_data_id); 627 $this.attr('data-orig_data_id', orig_data_id); 628 }); 629 $repeater_sub_clone.find('[id]').each(function () { 630 var $this = jQuery(this); 631 var prev_id = $this.attr('id'); 632 var orig_id = $this.attr('data-orig_id') != null ? $this.attr('data-orig_id') : prev_id; 633 var new_id = repeater.getNewName(prev_id); 634 $this.attr('id', new_id); 635 $this.attr('data-orig_id', orig_id); 636 }); 637 $repeater_sub_clone.find('[for]').each(function () { 638 var $this = jQuery(this); 639 var prev_for = $this.attr('for'); 640 var orig_for = $this.attr('data-orig_for') != null ? $this.attr('data-orig_for') : prev_for; 641 var new_for = repeater.getNewName(prev_for); 642 $this.attr('for', new_for); 643 $this.attr('data-orig_for', orig_for); 644 }); 645 var repeater_sub_html = $repeater_sub_clone[0].outerHTML; 646 var $repeater_count_field = $repeater.find('[name=' + $repeater.id + '_count]').eq(0); 647 var $button_add = $repeater_controls.find('.wpcf7cf_add').eq(0); 648 var $button_remove = $repeater_controls.find('.wpcf7cf_remove').eq(0); 649 var params = { 650 $repeater: $repeater, 651 $repeater_count_field: $repeater_count_field, 652 repeater_sub_html: repeater_sub_html, 653 $repeater_controls: $repeater_controls, 654 $button_add: $button_add, 655 $button_remove: $button_remove, 656 wpcf7cf_settings: wpcf7cf_settings 657 }; 658 this.params = params; 659 $button_add.on('click', null, repeater, function (e) { 660 var repeater = e.data; 661 repeater.updateSubs(params.$repeater.num_subs + 1); 662 }); 663 $button_remove.on('click', null, repeater, function (e) { 664 var repeater = e.data; 665 repeater.updateSubs(params.$repeater.num_subs - 1); 666 }); 667 jQuery('> .wpcf7cf_repeater_sub', params.$repeater).eq(0).remove(); // remove the first sub, it's just a template. 668 669 repeater.updateSubs($repeater.initial_subs); 670 repeater.updateButtons(); 671} 672 673Wpcf7cfRepeater.prototype.getNewName = function (previousName) { 674 var prev_parts = previousName.split('['); 675 previousName = prev_parts[0]; 676 var prev_suff = prev_parts.length > 1 ? '[' + prev_parts.splice(1).join('[') : ''; 677 var newName = previousName + '__{{repeater_sub_suffix}}' + prev_suff; 678 679 if (previousName.endsWith('_count')) { 680 newName = previousName.replace('_count', '__{{repeater_sub_suffix}}_count'); 681 } 682 683 return newName; 684}; 685 686Wpcf7cfRepeater.prototype.updateButtons = function () { 687 var repeater = this; 688 var params = repeater.params; 689 var num_subs = params.$repeater.num_subs; 690 var showButtonRemove = false;
691 var showButtonAdd = false; 692 693 if (params.$repeater.num_subs < params.$repeater.max) { 694 showButtonAdd = true; 695 } 696 697 if (params.$repeater.num_subs > params.$repeater.min) { 698 showButtonRemove = true; 699 } 700 701 if (showButtonAdd) { 702 params.$button_add.show(); 703 } else { 704 params.$button_add.hide(); 705 } 706 707 if (showButtonRemove) { 708 params.$button_remove.show(); 709 } else { 710 params.$button_remove.hide(); 711 } 712 713 params.$repeater_count_field.val(num_subs); 714}; 715 716Wpcf7cfRepeater.prototype.updateSubs = function (subs_to_show) { 717 var repeater = this; 718 var params = repeater.params; // make sure subs_to_show is a valid number 719 720 subs_to_show = subs_to_show < params.$repeater.min ? params.$repeater.min : subs_to_show; 721 subs_to_show = subs_to_show > params.$repeater.max ? params.$repeater.max : subs_to_show; 722 var subs_to_add = subs_to_show - params.$repeater.num_subs; 723 724 if (subs_to_add < 0) { 725 repeater.removeSubs(-subs_to_add); 726 } else if (subs_to_add > 0) { 727 repeater.addSubs(subs_to_add); 728 } 729}; 730/** 731 * add Subs to repeater 732 * @param {Number} subs_to_add 733 * @param {Number} index - zero-based. leave blank (or null) to append at the end 734 */ 735 736 737Wpcf7cfRepeater.prototype.addSubs = function (subs_to_add) { 738 var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 739 var $ = jQuery; 740 var params = this.params; 741 var repeater = this; 742 var form = repeater.form; 743 var $repeater = params.$repeater; 744 var $repeater_controls = params.$repeater_controls; 745 746 if (subs_to_add + $repeater.num_subs > $repeater.max) { 747 subs_to_add = $repeater.max - $repeater.num_subs; 748 } 749 750 var html_str = ''; 751 752 for (var i = 1; i <= subs_to_add; i++) { 753 var sub_suffix = $repeater.num_subs + i; 754 html_str += params.repeater_sub_html.replace(/\{\{repeater_sub_suffix\}\}/g, sub_suffix).replace(new RegExp('\{\{' + $repeater.orig_id + '_index\}\}', 'g'), '<span class="wpcf7cf-index wpcf7cf__' + $repeater.orig_id + '">' + sub_suffix + '</span>'); 755 } 756 757 var $html = jQuery(html_str); 758 jQuery('> .wpcf7cf_repeater_sub', $repeater).finish(); // finish any currently running animations immediately. 759 // Add the newly created fields to the form 760 761 if (index === null) { 762 $html.hide().insertBefore($repeater_controls).animate(wpcf7cf_show_animation, params.wpcf7cf_settings.animation_intime).trigger('wpcf7cf_repeater_added'); 763 } else { 764 $html.hide().insertBefore(jQuery('> .wpcf7cf_repeater_sub', $repeater).eq(index)).animate(wpcf7cf_show_animation, params.wpcf7cf_settings.animation_intime).trigger('wpcf7cf_repeater_added'); 765 } 766 767 jQuery('.wpcf7cf_repeater', $html).each(function () { 768 form.repeaters.push(new Wpcf7cfRepeater(jQuery(this), form)); 769 }); 770 form.$input_repeaters.val(JSON.stringify(form.repeaters.map(function (item) { 771 return item.params.$repeater.id; 772 }))); 773 $repeater.num_subs += subs_to_add; 774 775 if (index !== null) { 776 repeater.updateSuffixes(); 777 } 778 779 window.wpcf7cf.updateMultistepState(form.multistep); 780 form.updateGroups(); 781 form.updateEventListeners(); 782 form.displayFields(); 783 repeater.updateButtons(); // Exclusive Checkbox 784 785 $html.on('click', '.wpcf7-exclusive-checkbox input:checkbox', function () { 786 var name = $(this).attr('name'); 787 $html.find('input:checkbox[name="' + name + '"]').not(this).prop('checked', false); 788 }); //basic compatibility with material-design-for-contact-form-7 789 790 if (typeof window.cf7mdInit === "function") { 791 window.cf7mdInit(); 792 } 793 794 return false; 795}; 796/** TODO: implement this */ 797 798 799Wpcf7cfRepeater.prototype.updateSuffixes = function () { 800 // Loop trough all subs 801 // -- 1. update all fields, groups and repeaters names, id's, for's, ... 802 // -- 2. loop trough all repeaters 803 // -- update sub_html template for nested repeater 804 // -- call updateSuffixes() for nested repeater 805 var $repeater = this.params.$repeater; 806 var num_subs = this.params.$repeater.num_subs; 807 var form = this.form; 808 var orig_id = $repeater.attr('data-orig_data_id'); 809 var repeater_id = $repeater.attr('data-id'); 810 var repeater_suffix = repeater_id.replace(orig_id, ''); 811 var simplifiedDomArray = Object.values(wpcf7cf.get_simplified_dom_model(form.$form[0])); 812 813 var _loop = function _loop(i) { 814 var $sub = jQuery('> .wpcf7cf_repeater_sub', $repeater).eq(i); 815 var newIndex = i + 1; 816 var currentSuffix = $sub.attr('data-repeater_sub_suffix'); 817 var newSuffix = repeater_suffix + '__' + newIndex; 818 $sub.attr('data-repeater_sub_suffix', newSuffix); // update sub attr 819 820 $sub.find('.wpcf7cf__' + orig_id).html(newIndex); // update {{r_index}} parts 821 822 simplifiedDomArray.forEach(function (el) { 823 if (el.suffix !== currentSuffix) return; // TODO: may need an extra check to verify that the element is inside the current repeater 824 // (orig_id) . Otherwise problems may occur if there are repeaters on the same level. 825 826 var newName = el.name.replace(currentSuffix, newSuffix); 827 var pureElName = el.name.replace('[]', ''); 828 var pureNewName = newName.replace('[]', ''); 829 jQuery('[name="' + el.name + '"]', $sub).attr('name', newName); 830 jQuery('[id="' + el.name + '"]', $sub).attr('id', newName); 831 jQuery('label[for="' + el.name + '"]', $sub).attr('for', newName); 832 var $nested_repeater = jQuery('[data-id="' + el.name + '"]', $sub); 833 $nested_repeater.attr('data-id', newName); 834 jQuery('.wpcf7-form-control-wrap.' + pureElName, $sub).removeClass(pureElName).addClass(pureNewName); 835 836 if (el.type === 'repeater') { 837 var nested_repeater = form.repeaters.find(function (repeater) { 838 return repeater.params.$repeater.get(0) === $nested_repeater.get(0); 839 }); 840 if (!nested_repeater) return; 841 nested_repeater.params.repeater_sub_html = wpcf7cf.updateRepeaterSubHTML(nested_repeater.params.repeater_sub_html, currentSuffix, newSuffix, nested_repeater.params.$repeater.parentRepeaters); 842 nested_repeater.updateSuffixes(); 843 } 844 }); 845 }; 846 847 for (var i = 0; i < num_subs; i++) { 848 _loop(i); 849 } 850}; 851/** 852 * Return the parent repeaters, order is not guaranteed. 853 */ 854 855 856Wpcf7cfRepeater.prototype.getParentRepeaters = function () { 857 var simplifiedDomArray = Object.values(wpcf7cf.get_simplified_dom_model(form.$form[0])); 858 form.repeaters.map(function (repeater) {}); 859}; 860 861Wpcf7cfRepeater.prototype.removeSubs = function (subs_to_remove) { 862 var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 863 var $ = jQuery; 864 var repeater = this; 865 var params = repeater.params; 866 var form = repeater.form; 867 var $repeater = params.$repeater; 868 869 if ($repeater.num_subs - subs_to_remove < $repeater.min) { 870 subs_to_remove = $repeater.num_subs - $repeater.min; 871 } 872 873 if (index === null) { 874 index = $repeater.num_subs - subs_to_remove; 875 } 876 877 $repeater.num_subs -= subs_to_remove; 878 jQuery('> .wpcf7cf_repeater_sub', $repeater).finish(); // finish any currently running animations immediately. 879 880 jQuery('> .wpcf7cf_repeater_sub', $repeater).slice(index, index + subs_to_remove).animate(wpcf7cf_hide_animation, { 881 duration: params.wpcf7cf_settings.animation_intime, 882 done: function done() { 883 var $this = jQuery(this); //remove the actual fields from the form 884 885 $this.remove(); 886 params.$repeater.trigger('wpcf7cf_repeater_removed'); 887 window.wpcf7cf.updateMultistepState(form.multistep); 888 form.updateGroups(); 889 form.updateEventListeners(); 890 form.displayFields(); 891 repeater.updateButtons(); 892 893 if (index !== null) { 894 repeater.updateSuffixes(); 895 } 896 } 897 }); 898 return false;
899}; 900 901function Wpcf7cfMultistep($multistep, form) { 902 var multistep = this; 903 multistep.$multistep = $multistep; 904 multistep.form = form; 905 multistep.$steps = $multistep.find('.wpcf7cf_step'); 906 multistep.$btn_next = $multistep.find('.wpcf7cf_next'); 907 multistep.$btn_prev = $multistep.find('.wpcf7cf_prev'); 908 multistep.$dots = $multistep.find('.wpcf7cf_steps-dots'); 909 multistep.currentStep = 0; 910 multistep.numSteps = multistep.$steps.length; 911 multistep.$dots.html(''); 912 913 for (var i = 1; i <= multistep.numSteps; i++) { 914 multistep.$dots.append("\n <div class=\"dot\" data-step=\"".concat(i, "\">\n <div class=\"step-index\">").concat(i, "</div>\n <div class=\"step-title\">").concat(multistep.$steps.eq(i - 1).attr('data-title'), "</div>\n </div>\n ")); 915 } 916 917 multistep.$btn_next.on('click.wpcf7cf_step', /*#__PURE__*/_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_4___default()( /*#__PURE__*/_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3___default.a.mark(function _callee() { 918 var result; 919 return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3___default.a.wrap(function _callee$(_context) { 920 while (1) { 921 switch (_context.prev = _context.next) { 922 case 0: 923 multistep.$btn_next.addClass('disabled').attr('disabled', true); 924 _context.next = 3; 925 return multistep.validateStep(multistep.currentStep); 926 927 case 3: 928 result = _context.sent; 929 930 if (result === 'success') { 931 multistep.moveToStep(multistep.currentStep + 1); 932 } 933 934 case 5: 935 case "end": 936 return _context.stop(); 937 } 938 } 939 }, _callee); 940 }))); // If form is submitted (by pressing Enter for example), and if we are not on the last step, 941 // then trigger click event on the $btn_next button instead. 942 943 multistep.form.$form.on('submit.wpcf7cf_step', function (e) { 944 if (multistep.currentStep !== multistep.numSteps) { 945 multistep.$btn_next.trigger('click.wpcf7cf_step'); 946 e.stopImmediatePropagation(); 947 return false; 948 } 949 }); 950 multistep.$btn_prev.on('click', function () { 951 multistep.moveToStep(multistep.currentStep - 1); 952 }); 953 multistep.moveToStep(1); 954} 955 956jQuery(document).ajaxComplete(function (e, xhr, settings) { 957 if (xhr.hasOwnProperty('responseJSON') && xhr.responseJSON != null && xhr.responseJSON.hasOwnProperty('status') && xhr.responseJSON.hasOwnProperty('into') && xhr.responseJSON.status === "mail_success") { 958 jQuery(xhr.responseJSON.into).trigger('reset.wpcf7cf'); 959 } 960}); 961 962Wpcf7cfMultistep.prototype.validateStep = function (step_index) { 963 var multistep = this; 964 var $multistep = multistep.$multistep; 965 var $form = multistep.form.$form; 966 var form = multistep.form; 967 $form.find('.wpcf7-response-output').addClass('wpcf7-display-none'); 968 return new Promise(function (resolve) { 969 var fd = new FormData(); // Make sure to add file fields to FormData 970 971 jQuery.each($form.find('[data-id="step-' + step_index + '"] input[type="file"]'), function (index, el) { 972 if (!el.files.length) return true; // = continue 973 974 var file = el.files[0]; 975 var fieldName = el.name; 976 fd.append(fieldName, file); 977 }); 978 var formdata = $form.serializeArray(); 979 jQuery.each(formdata, function (key, input) { 980 fd.append(input.name, input.value); 981 }); 982 jQuery.ajax({ 983 url: wpcf7cf_global_settings.ajaxurl + '?action=wpcf7cf_validate_step', 984 type: 'POST', 985 data: fd, 986 processData: false, 987 contentType: false, 988 dataType: 'json' 989 }).done(function (json) { 990 $multistep.find('.wpcf7-form-control-wrap .wpcf7-not-valid-tip').remove(); 991 $multistep.find('.wpcf7-not-valid').removeClass('wpcf7-not-valid'); 992 $multistep.find('.wpcf7-response-output').remove(); 993 $multistep.find('.wpcf7-response-output.wpcf7-validation-errors').removeClass('wpcf7-validation-errors'); 994 multistep.$btn_next.removeClass('disabled').attr('disabled', false); 995 996 if (!json.success) { 997 var checkError = 0; 998 jQuery.each(json.invalid_fields, function (index, el) { 999 if ($multistep.find('input[name="' + index + '"]').length || $multistep.find('input[name="' + index + '[]"]').length || $multistep.find('select[name="' + index + '"]').length || $multistep.find('select[name="' + index + '[]"]').length || $multistep.find('textarea[name="' + index + '"]').length || $multistep.find('textarea[name="' + index + '[]"]').length) { 1000 checkError = checkError + 1; 1001 var controlWrap = form.get('.wpcf7-form-control-wrap.' + index); 1002 controlWrap.find('.wpcf7-form-control').addClass('wpcf7-not-valid'); 1003 controlWrap.find('span.wpcf7-not-valid-tip').remove(); 1004 controlWrap.append('<span role="alert" class="wpcf7-not-valid-tip">' + el.reason + '</span>'); 1005 } 1006 }); 1007 resolve('failed'); 1008 $multistep.parent().find('.wpcf7-response-output').removeClass('wpcf7-display-none').html(json.message); 1009 wpcf7.setStatus($form, 'invalid');
1010 multistep.$steps.trigger('wpcf7cf_step_invalid'); // wpcf7.triggerEvent( data.into, 'invalid', detail ); 1011 } else if (json.success) { 1012 wpcf7.setStatus($form, 'init'); 1013 resolve('success'); 1014 return false; 1015 } 1016 }).fail(function () { 1017 resolve('error'); 1018 }).always(function () {// do nothing 1019 }); 1020 }); 1021}; 1022 1023Wpcf7cfMultistep.prototype.moveToStep = function (step_index) { 1024 var multistep = this; 1025 var previousStep = multistep.currentStep; 1026 multistep.currentStep = step_index > multistep.numSteps ? multistep.numSteps : step_index < 1 ? 1 : step_index; // ANIMATION DISABLED FOR NOW cause it's ugly 1027 // multistep.$steps.animate(wpcf7cf_hide_step_animation, multistep.form.settings.animation_outtime); 1028 // multistep.$steps.eq(multistep.currentStep-1).animate(wpcf7cf_show_step_animation, multistep.form.settings.animation_intime); 1029 1030 multistep.$multistep.attr('data-current_step', multistep.currentStep); 1031 multistep.$steps.hide(); 1032 multistep.$steps.eq(multistep.currentStep - 1).show().trigger('wpcf7cf_change_step', [previousStep, multistep.currentStep]); 1033 var formEl = multistep.form.$form[0]; 1034 var topOffset = formEl.getBoundingClientRect().top; 1035 1036 if (topOffset < 0 && previousStep > 0) { 1037 formEl.scrollIntoView({ 1038 behavior: "smooth" 1039 }); 1040 } 1041 1042 multistep.form.updateSummaryFields(); 1043 window.wpcf7cf.updateMultistepState(multistep); 1044}; 1045 1046Wpcf7cfMultistep.prototype.getFieldsInStep = function (step_index) { 1047 wpcf7cf_reload_dom(this.form.$form); 1048 var inStep = false; 1049 return Object.values(wpcf7cf_dom).filter(function (item, i) { 1050 if (item.type == 'step') { 1051 inStep = item.val == step_index + ''; 1052 } 1053 1054 return inStep && item.type == 'input'; 1055 }).map(function (item) { 1056 return item.name; 1057 }); 1058}; // END PRO ONLY 1059 1060/** 1061 * @global 1062 * @namespace wpcf7cf 1063 */ 1064 1065 1066window.wpcf7cf = { 1067 hideGroup: function hideGroup($group, animate) {}, 1068 showGroup: function showGroup($group, animate) {}, 1069 updateRepeaterSubHTML: function updateRepeaterSubHTML(html, oldSuffix, newSuffix, parentRepeaters) { 1070 var oldIndexes = oldSuffix.split('__'); 1071 oldIndexes.shift(); // remove first empty element 1072 1073 var newIndexes = newSuffix.split('__'); 1074 newIndexes.shift(); // remove first empty element 1075 1076 var returnHtml = html; 1077 1078 if (oldIndexes && newIndexes && oldIndexes.length === parentRepeaters.length && newIndexes.length === parentRepeaters.length) { 1079 var parentRepeatersInfo = parentRepeaters.map(function (repeaterId, i) { 1080 return _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()({}, repeaterId.split('__')[0], [oldIndexes[i], newIndexes[i]]); 1081 }); 1082 var length = parentRepeatersInfo.length; 1083 var replacements = oldIndexes.map(function (oldIndex, i) { 1084 return ['__' + oldIndexes.slice(0, length - i).join('__'), '__' + newIndexes.slice(0, length - i).join('__')]; 1085 }); 1086 1087 for (var i = 0; i < length; i++) { 1088 var id = Object.keys(parentRepeatersInfo[i])[0]; 1089 var find = parentRepeatersInfo[i][id][0]; 1090 var repl = parentRepeatersInfo[i][id][1]; 1091 replacements.push(["<span class=\"wpcf7cf-index wpcf7cf__".concat(id, "\">").concat(find, "<\\/span>"), "<span class=\"wpcf7cf-index wpcf7cf__".concat(id, "\">").concat(repl, "</span>")]); 1092 } 1093 1094 replacements.forEach(function (_ref3) { 1095 var _ref4 = _babel_runtime_helpers_slicedToArray__WEBPACK_IMPORTED_MODULE_1___default()(_ref3, 2), 1096 oldSuffix = _ref4[0], 1097 newSuffix = _ref4[1]; 1098 1099 returnHtml = returnHtml.replace(new RegExp(oldSuffix, 'g'), newSuffix); 1100 }); 1101 } 1102 1103 return returnHtml; 1104 }, 1105 // keep this for backwards compatibility 1106 initForm: function initForm($forms) { 1107 $forms.each(function () { 1108 var $form = jQuery(this); // only add form is its class is "wpcf7-form" and if the form was not previously added 1109 1110 if ($form.hasClass('wpcf7-form') && !wpcf7cf_forms.some(function (form) { 1111 return form.$form.get(0) === $form.get(0); 1112 })) { 1113 wpcf7cf_forms.push(new Wpcf7cfForm($form)); 1114 } 1115 }); 1116 }, 1117 getWpcf7cfForm: function getWpcf7cfForm($form) { 1118 var matched_forms = wpcf7cf_forms.filter(function (form) { 1119 var f1 = form.$form.get(0); 1120 var f2 = $form.get(0); 1121 return form.$form.get(0) === $form.get(0); 1122 }); 1123 1124 if (matched_forms.length) { 1125 return matched_forms[0]; 1126 } 1127 1128 return false;
1129 }, 1130 get_nested_conditions: function get_nested_conditions(conditions, $current_form) { 1131 //loop trough conditions. Then loop trough the dom, and each repeater we pass we should update all sub_values we encounter with __index 1132 wpcf7cf_reload_dom($current_form); 1133 var groups = Object.values(wpcf7cf_dom).filter(function (item, i) { 1134 return item.type === 'group'; 1135 }); 1136 var sub_conditions = []; 1137 1138 for (var i = 0; i < groups.length; i++) { 1139 var g = groups[i]; 1140 var relevant_conditions = conditions.filter(function (condition, i) { 1141 return condition.then_field === g.original_name; 1142 }); 1143 var relevant_conditions = relevant_conditions.map(function (item, i) { 1144 return { 1145 then_field: g.name, 1146 and_rules: item.and_rules.map(function (and_rule, i) { 1147 return { 1148 if_field: and_rule.if_field + g.suffix, 1149 if_value: and_rule.if_value, 1150 operator: and_rule.operator 1151 }; 1152 }) 1153 }; 1154 }); 1155 sub_conditions = sub_conditions.concat(relevant_conditions); 1156 } 1157 1158 return sub_conditions; 1159 }, 1160 get_simplified_dom_model: function get_simplified_dom_model(currentNode) { 1161 var simplified_dom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 1162 var parentGroups = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; 1163 var parentRepeaters = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : []; 1164 var type = currentNode.classList && currentNode.classList.contains('wpcf7cf_repeater') ? 'repeater' : currentNode.dataset["class"] == 'wpcf7cf_group' ? 'group' : currentNode.className == 'wpcf7cf_step' ? 'step' : currentNode.hasAttribute('name') && !currentNode.disabled ? 'input' : false; 1165 1166 var newParentRepeaters = _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default()(parentRepeaters); 1167 1168 var newParentGroups = _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default()(parentGroups); 1169 1170 if (type) { 1171 var name = type === 'input' ? currentNode.getAttribute('name') : currentNode.dataset.id; 1172 1173 if (type === 'repeater') { 1174 newParentRepeaters.push(name); 1175 } 1176 1177 if (type === 'group') { 1178 newParentGroups.push(name); 1179 } // skip _wpcf7 hidden fields 1180 1181 1182 if (name.substring(0, 6) === '_wpcf7') return {}; 1183 var original_name = type === 'repeater' || type === 'group' ? currentNode.dataset.orig_data_id : type === 'input' ? currentNode.getAttribute('data-orig_name') || name : name; 1184 var nameWithoutBrackets = name.replace('[]', ''); 1185 var originalNameWithoutBrackets = original_name.replace('[]', ''); 1186 var val = type === 'step' ? [currentNode.dataset.id.substring(5)] : []; 1187 var parentGroup = 'parent-group'; 1188 var suffix = nameWithoutBrackets.replace(originalNameWithoutBrackets, ''); 1189 1190 if (!simplified_dom[name]) { 1191 // init entry 1192 simplified_dom[name] = { 1193 name: name, 1194 type: type, 1195 original_name: original_name, 1196 suffix: suffix, 1197 val: val, 1198 parentGroups: parentGroups, 1199 parentRepeaters: parentRepeaters 1200 }; 1201 } 1202 1203 if (type === 'input') { 1204 // skip unchecked checkboxes and radiobuttons 1205 if ((currentNode.type === 'checkbox' || currentNode.type === 'radio') && !currentNode.checked) return {}; // if multiselect, make sure to add all the values 1206 1207 if (currentNode.multiple && currentNode.options) { 1208 simplified_dom[name].val = Object.values(currentNode.options).filter(function (o) { 1209 return o.selected; 1210 }).map(function (o) { 1211 return o.value; 1212 }); 1213 } else { 1214 simplified_dom[name].val.push(currentNode.value); 1215 } 1216 } 1217 } 1218 1219 Array.from(currentNode.children).forEach(function (childNode) { 1220 var dom = wpcf7cf.get_simplified_dom_model(childNode, simplified_dom, newParentGroups, newParentRepeaters); 1221 simplified_dom = _objectSpread(_objectSpread({}, dom), simplified_dom); 1222 }); 1223 return simplified_dom; 1224 }, 1225 updateMultistepState: function updateMultistepState(multistep) { 1226 if (multistep == null) return; // update hidden input field 1227 1228 var stepsData = { 1229 currentStep: multistep.currentStep, 1230 numSteps: multistep.numSteps, 1231 fieldsInCurrentStep: multistep.getFieldsInStep(multistep.currentStep) 1232 }; 1233 multistep.form.$input_steps.val(JSON.stringify(stepsData)); // update Buttons 1234 1235 multistep.$btn_prev.removeClass('disabled').attr('disabled', false); 1236 multistep.$btn_next.removeClass('disabled').attr('disabled', false); 1237 1238 if (multistep.currentStep == multistep.numSteps) { 1239 multistep.$btn_next.addClass('disabled').attr('disabled', true); 1240 } 1241 1242 if (multistep.currentStep == 1) { 1243 multistep.$btn_prev.addClass('disabled').attr('disabled', true); 1244 } // replace next button with submit button on last step.
1245 // TODO: make this depend on a setting 1246 1247 1248 var $submit_button = multistep.form.$form.find('input[type="submit"]').eq(0); 1249 var $ajax_loader = multistep.form.$form.find('.ajax-loader').eq(0); 1250 1251 if (multistep.currentStep == multistep.numSteps) { 1252 multistep.$btn_next.hide(); 1253 $ajax_loader.detach().appendTo(multistep.$btn_next.parent()); 1254 $submit_button.detach().appendTo(multistep.$btn_next.parent()); 1255 $submit_button.show(); 1256 } else { 1257 $submit_button.hide(); 1258 multistep.$btn_next.show(); 1259 } // update dots 1260 1261 1262 var $dots = multistep.$dots.find('.dot'); 1263 $dots.removeClass('active').removeClass('completed'); 1264 1265 for (var step = 1; step <= multistep.numSteps; step++) { 1266 if (step < multistep.currentStep) { 1267 $dots.eq(step - 1).addClass('completed'); 1268 } else if (step == multistep.currentStep) { 1269 $dots.eq(step - 1).addClass('active'); 1270 } 1271 } 1272 }, 1273 should_group_be_shown: function should_group_be_shown(condition) { 1274 var show_group = true; 1275 1276 for (var and_rule_i = 0; and_rule_i < condition.and_rules.length; and_rule_i++) { 1277 var condition_ok = false; 1278 var condition_and_rule = condition.and_rules[and_rule_i]; 1279 var inputField = wpcf7cf_getFieldByName(condition_and_rule.if_field); 1280 if (!inputField) continue; // field not found 1281 1282 var if_val = condition_and_rule.if_value; 1283 var operator = condition_and_rule.operator; //backwards compat 1284 1285 operator = operator === 'â¤' ? 'less than or equals' : operator; 1286 operator = operator === 'â¥' ? 'greater than or equals' : operator; 1287 operator = operator === '>' ? 'greater than' : operator; 1288 operator = operator === '<' ? 'less than' : operator; 1289 var $field = operator === 'function' && jQuery("[name=\"".concat(inputField.name, "\"]")).eq(0); 1290 condition_ok = this.isConditionTrue(inputField.val, operator, if_val, $field); 1291 show_group = show_group && condition_ok; 1292 } 1293 1294 return show_group; 1295 }, 1296 isConditionTrue: function isConditionTrue(values, operator) { 1297 var testValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; 1298 var $field = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : jQuery(); 1299 1300 if (!Array.isArray(values)) { 1301 values = [values]; 1302 } 1303 1304 var condition_ok = false; // start by assuming that the condition is not met 1305 // Considered EMPTY: [] [''] [null] ['',null] [,,''] 1306 // Considered NOT EMPTY: [0] ['ab','c'] ['',0,null] 1307 1308 var valuesAreEmpty = values.length === 0 || values.every(function (v) { 1309 return !v && v !== 0; 1310 }); // 0 is not considered empty 1311 // special cases: [] equals '' => TRUE; [] not equals '' => FALSE 1312 1313 if (operator === 'equals' && testValue === '' && valuesAreEmpty) { 1314 return true; 1315 } 1316 1317 if (operator === 'not equals' && testValue === '' && valuesAreEmpty) { 1318 return false; 1319 } 1320 1321 if (valuesAreEmpty) { 1322 if (operator === 'is empty') { 1323 condition_ok = true; 1324 } 1325 } else { 1326 if (operator === 'not empty') { 1327 condition_ok = true; 1328 } 1329 } 1330 1331 var testValueNumber = isFinite(parseFloat(testValue)) ? parseFloat(testValue) : NaN; 1332 1333 if (operator === 'not equals' || operator === 'not equals (regex)') { 1334 // start by assuming that the condition is met 1335 condition_ok = true; 1336 } 1337 1338 if (operator === 'function' && typeof window[testValue] == 'function' && window[testValue]($field) // here we call the actual user defined function 1339 ) { 1340 condition_ok = true; 1341 } 1342 1343 var regex_patt = /.*/i; // fallback regex pattern 1344 1345 var isValidRegex = true; 1346 1347 if (operator === 'equals (regex)' || operator === 'not equals (regex)') { 1348 try { 1349 regex_patt = new RegExp(testValue, 'i'); 1350 } catch (e) { 1351 isValidRegex = false; 1352 } 1353 } 1354 1355 for (var i = 0; i < values.length; i++) { 1356 var value = values[i]; 1357 var valueNumber = isFinite(parseFloat(value)) ? parseFloat(value) : NaN; 1358 var valsAreNumbers = !isNaN(valueNumber) && !isNaN(testValueNumber); 1359 1360 if (operator === 'equals' && value === testValue || operator === 'equals (regex)' && regex_patt.test(value) || operator === 'greater than' && valsAreNumbers && valueNumber > testValueNumber || operator === 'less than' && valsAreNumbers && valueNumber < testValueNumber || operator === 'greater than or equals' && valsAreNumbers && valueNumber >= testValueNumber || operator === 'less than or equals' && valsAreNumbers && valueNumber <= testValueNumber) { 1361 condition_ok = true; 1362 break; 1363 } else if (operator === 'not equals' && value === testValue || operator === 'not equals (regex)' && regex_patt.test(value)) { 1364 condition_ok = false;
1365 break; 1366 } 1367 } 1368 1369 return condition_ok; 1370 }, 1371 getFormObj: function getFormObj($form) { 1372 if (typeof $form === 'string') { 1373 $form = jQuery($form).eq(0); 1374 } 1375 1376 return wpcf7cf.getWpcf7cfForm($form); 1377 }, 1378 getRepeaterObj: function getRepeaterObj($form, repeaterDataId) { 1379 var form = wpcf7cf.getFormObj($form); 1380 var repeater = form.repeaters.find(function (repeater) { 1381 return repeater.params.$repeater.attr('data-id') === repeaterDataId; 1382 }); 1383 return repeater; 1384 }, 1385 getMultiStepObj: function getMultiStepObj($form) { 1386 var form = wpcf7cf.getFormObj($form); 1387 return form.multistep; 1388 }, 1389 1390 /** 1391 * Append a new sub-entry to the repeater with the name `repeaterDataId` inside the form `$form` 1392 * @memberof wpcf7cf 1393 * @function wpcf7cf.repeaterAddSub 1394 * @link 1395 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1396 * @param {String} repeaterDataId - *data-id* attribute of the repeater. Normally this is simply the name of the repeater. However, in case of a nested repeater you need to append the name with the correct suffix. For example `my-nested-repeater__1__3`. Hint (check the `data-id` attribute in the HTML code to find the correct suffix) 1397 */ 1398 repeaterAddSub: function repeaterAddSub($form, repeaterDataId) { 1399 var repeater = wpcf7cf.getRepeaterObj($form, repeaterDataId); 1400 repeater.updateSubs(repeater.params.$repeater.num_subs + 1); 1401 }, 1402 1403 /** 1404 * Insert a new sub-entry at the given `index` of the repeater with the name `repeaterDataId` inside the form `$form` 1405 * @memberof wpcf7cf 1406 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1407 * @param {String} repeaterDataId - *data-id* attribute of the repeater. 1408 * @param {Number} index - position where to insert the new sub-entry within the repeater 1409 */ 1410 repeaterAddSubAtIndex: function repeaterAddSubAtIndex($form, repeaterDataId, index) { 1411 var repeater = wpcf7cf.getRepeaterObj($form, repeaterDataId); 1412 repeater.addSubs(1, index); 1413 }, 1414 1415 /** 1416 * Remove the sub-entry at the given `index` of the repeater with the *data-id* attribute of `repeaterDataId` inside the form `$form` 1417 * @memberof wpcf7cf 1418 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1419 * @param {String} repeaterDataId - *data-id* attribute of the repeater. 1420 * @param {Number} index - position where to insert the new sub-entry within the repeater 1421 */ 1422 repeaterRemoveSubAtIndex: function repeaterRemoveSubAtIndex($form, repeaterDataId, index) { 1423 var repeater = wpcf7cf.getRepeaterObj($form, repeaterDataId); 1424 repeater.removeSubs(1, index); 1425 }, 1426 1427 /** 1428 * Remove the last sub-entry from the repeater with the *data-id* attribute of `repeaterDataId` inside the form `$form` 1429 * @memberof wpcf7cf 1430 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1431 * @param {String} repeaterDataId - *data-id* attribute of the repeater. 1432 * @param {Number} index - position where to insert the new sub-entry within the repeater 1433 */ 1434 repeaterRemoveSub: function repeaterRemoveSub($form, repeaterDataId) { 1435 var repeater = wpcf7cf.getRepeaterObj($form, repeaterDataId); 1436 repeater.updateSubs(repeater.params.$repeater.num_subs - 1); 1437 }, 1438 1439 /** 1440 * Set the number of subs for the repeater with the *data-id* attribute of `repeaterDataId` inside the form `$form`. 1441 * Subs are either appended to or removed from the end of the repeater. 1442 * @memberof wpcf7cf 1443 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1444 * @param {String} repeaterDataId - *data-id* attribute of the repeater. 1445 * @param {Number} numberOfSubs - position where to insert the new sub-entry within the repeater 1446 */ 1447 repeaterSetNumberOfSubs: function repeaterSetNumberOfSubs($form, repeaterDataId, numberOfSubs) { 1448 var repeater = wpcf7cf.getRepeaterObj($form, repeaterDataId); 1449 repeater.updateSubs(numberOfSubs); 1450 }, 1451 1452 /** 1453 * Move to step number `step`, ignoring any validation. 1454 * @memberof wpcf7cf 1455 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1456 * @param {*} step 1457 */ 1458 multistepMoveToStep: function multistepMoveToStep($form, step) { 1459 var multistep = wpcf7cf.getMultiStepObj($form); 1460 multistep.moveToStep(step); 1461 }, 1462 1463 /** 1464 * Validate the current step, and move to step number `step` if val
1464idation passes. 1465 * @memberof wpcf7cf 1466 * @param {String|JQuery} $form - JQuery object or css-selector representing the form 1467 * @param {Number} step 1468 */ 1469 multistepMoveToStepWithValidation: function multistepMoveToStepWithValidation($form, step) { 1470 return _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_4___default()( /*#__PURE__*/_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3___default.a.mark(function _callee2() { 1471 var multistep, result; 1472 return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_3___default.a.wrap(function _callee2$(_context2) { 1473 while (1) { 1474 switch (_context2.prev = _context2.next) { 1475 case 0: 1476 multistep = wpcf7cf.getMultiStepObj($form); 1477 _context2.next = 3; 1478 return multistep.validateStep(multistep.currentStep); 1479 1480 case 3: 1481 result = _context2.sent; 1482 1483 if (result === 'success') { 1484 multistep.moveToStep(step); 1485 } 1486 1487 case 5: 1488 case "end": 1489 return _context2.stop(); 1490 } 1491 } 1492 }, _callee2); 1493 }))(); 1494 } 1495}; 1496jQuery('.wpcf7-form').each(function () { 1497 wpcf7cf_forms.push(new Wpcf7cfForm(jQuery(this))); 1498}); // Call displayFields again on all forms 1499// Necessary in case some theme or plugin changed a form value by the time the entire page is fully loaded. 1500 1501jQuery('document').on('ready', function () { 1502 wpcf7cf_forms.forEach(function (f) { 1503 f.displayFields(); 1504 }); 1505});
1505 // fix for exclusive checkboxes in IE (this will call the change-event again after all other checkboxes are unchecked, triggering the display_fields() function) 1506 1507var old_wpcf7ExclusiveCheckbox = jQuery.fn.wpcf7ExclusiveCheckbox; 1508 1509jQuery.fn.wpcf7ExclusiveCheckbox = function () { 1510 return this.find('input:checkbox').on('click', function () { 1511 var name = jQuery(this).attr('name'); 1512 jQuery(this).closest('form').find('input:checkbox[name="' + name + '"]').not(this).prop('checked', false).eq(0).change(); 1513 }); 1514}; 1515 1516/***/ }), 1517
vendor: 593 bytes, lines 1518-1538
1518/***/ "./node_modules/@babel/runtime/helpers/arrayLikeToArray.js": 1519/*!*****************************************************************!*\ 1520 !*** ./node_modules/@babel/runtime/helpers/arrayLikeToArray.js ***! 1521 \*****************************************************************/ 1522/*! no static exports found */ 1523/***/ (function(module, exports) { 1524 1525function _arrayLikeToArray(arr, len) { 1526 if (len == null || len > arr.length) len = arr.length; 1527 1528 for (var i = 0, arr2 = new Array(len); i < len; i++) { 1529 arr2[i] = arr[i]; 1530 } 1531 1532 return arr2; 1533} 1534 1535module.exports = _arrayLikeToArray; 1536 1537/***/ }), 1538
vendor: 457 bytes, lines 1539-1553
1539/***/ "./node_modules/@babel/runtime/helpers/arrayWithHoles.js": 1540/*!***************************************************************!*\ 1541 !*** ./node_modules/@babel/runtime/helpers/arrayWithHoles.js ***! 1542 \***************************************************************/ 1543/*! no static exports found */ 1544/***/ (function(module, exports) { 1545 1546function _arrayWithHoles(arr) { 1547 if (Array.isArray(arr)) return arr; 1548} 1549 1550module.exports = _arrayWithHoles; 1551 1552/***/ }), 1553
vendor: 646 bytes, lines 1554-1570
1554/***/ "./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js": 1555/*!******************************************************************!*\ 1556 !*** ./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js ***! 1557 \******************************************************************/ 1558/*! no static exports found */ 1559/***/ (function(module, exports, __webpack_require__) { 1560 1561var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray */ "./node_modules/@babel/runtime/helpers/arrayLikeToArray.js"); 1562 1563function _arrayWithoutHoles(arr) { 1564 if (Array.isArray(arr)) return arrayLikeToArray(arr); 1565} 1566 1567module.exports = _arrayWithoutHoles; 1568 1569/***/ }), 1570
vendor: 1,168 bytes, lines 1571-1617
1571/***/ "./node_modules/@babel/runtime/helpers/asyncToGenerator.js": 1572/*!*****************************************************************!*\ 1573 !*** ./node_modules/@babel/runtime/helpers/asyncToGenerator.js ***! 1574 \*****************************************************************/ 1575/*! no static exports found */ 1576/***/ (function(module, exports) { 1577 1578function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { 1579 try { 1580 var info = gen[key](arg); 1581 var value = info.value; 1582 } catch (error) { 1583 reject(error); 1584 return; 1585 } 1586 1587 if (info.done) { 1588 resolve(value); 1589 } else { 1590 Promise.resolve(value).then(_next, _throw); 1591 } 1592} 1593 1594function _asyncToGenerator(fn) { 1595 return function () { 1596 var self = this, 1597 args = arguments; 1598 return new Promise(function (resolve, reject) { 1599 var gen = fn.apply(self, args); 1600 1601 function _next(value) { 1602 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); 1603 } 1604 1605 function _throw(err) { 1606 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); 1607 } 1608 1609 _next(undefined); 1610 }); 1611 }; 1612} 1613 1614module.exports = _asyncToGenerator; 1615 1616/***/ }), 1617
vendor: 640 bytes, lines 1618-1643
1618/***/ "./node_modules/@babel/runtime/helpers/defineProperty.js": 1619/*!***************************************************************!*\ 1620 !*** ./node_modules/@babel/runtime/helpers/defineProperty.js ***! 1621 \***************************************************************/ 1622/*! no static exports found */ 1623/***/ (function(module, exports) { 1624 1625function _defineProperty(obj, key, value) { 1626 if (key in obj) { 1627 Object.defineProperty(obj, key, { 1628 value: value, 1629 enumerable: true, 1630 configurable: true, 1631 writable: true 1632 }); 1633 } else { 1634 obj[key] = value; 1635 } 1636 1637 return obj; 1638} 1639 1640module.exports = _defineProperty; 1641 1642/***/ }), 1643
vendor: 523 bytes, lines 1644-1658
1644/***/ "./node_modules/@babel/runtime/helpers/iterableToArray.js": 1645/*!****************************************************************!*\ 1646 !*** ./node_modules/@babel/runtime/helpers/iterableToArray.js ***! 1647 \****************************************************************/ 1648/*! no static exports found */ 1649/***/ (function(module, exports) { 1650 1651function _iterableToArray(iter) { 1652 if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); 1653} 1654 1655module.exports = _iterableToArray; 1656 1657/***/ }), 1658
vendor: 980 bytes, lines 1659-1696
1659/***/ "./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js": 1660/*!*********************************************************************!*\ 1661 !*** ./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js ***! 1662 \*********************************************************************/ 1663/*! no static exports found */ 1664/***/ (function(module, exports) { 1665 1666function _iterableToArrayLimit(arr, i) { 1667 if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 1668 var _arr = []; 1669 var _n = true; 1670 var _d = false; 1671 var _e = undefined; 1672 1673 try { 1674 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 1675 _arr.push(_s.value); 1676 1677 if (i && _arr.length === i) break; 1678 } 1679 } catch (err) { 1680 _d = true; 1681 _e = err; 1682 } finally { 1683 try { 1684 if (!_n && _i["return"] != null) _i["return"](); 1685 } finally { 1686 if (_d) throw _e; 1687 } 1688 } 1689 1690 return _arr; 1691} 1692 1693module.exports = _iterableToArrayLimit; 1694 1695/***/ }), 1696
vendor: 586 bytes, lines 1697-1711
1697/***/ "./node_modules/@babel/runtime/helpers/nonIterableRest.js": 1698/*!****************************************************************!*\ 1699 !*** ./node_modules/@babel/runtime/helpers/nonIterableRest.js ***! 1700 \****************************************************************/ 1701/*! no static exports found */ 1702/***/ (function(module, exports) { 1703 1704function _nonIterableRest() { 1705 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 1706} 1707 1708module.exports = _nonIterableRest; 1709 1710/***/ }), 1711
vendor: 593 bytes, lines 1712-1726
1712/***/ "./node_modules/@babel/runtime/helpers/nonIterableSpread.js": 1713/*!******************************************************************!*\ 1714 !*** ./node_modules/@babel/runtime/helpers/nonIterableSpread.js ***! 1715 \******************************************************************/ 1716/*! no static exports found */ 1717/***/ (function(module, exports) { 1718 1719function _nonIterableSpread() { 1720 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 1721} 1722 1723module.exports = _nonIterableSpread; 1724 1725/***/ }), 1726
vendor: 1,119 bytes, lines 1727-1749
1727/***/ "./node_modules/@babel/runtime/helpers/slicedToArray.js": 1728/*!**************************************************************!*\ 1729 !*** ./node_modules/@babel/runtime/helpers/slicedToArray.js ***! 1730 \**************************************************************/ 1731/*! no static exports found */ 1732/***/ (function(module, exports, __webpack_require__) { 1733 1734var arrayWithHoles = __webpack_require__(/*! ./arrayWithHoles */ "./node_modules/@babel/runtime/helpers/arrayWithHoles.js"); 1735 1736var iterableToArrayLimit = __webpack_require__(/*! ./iterableToArrayLimit */ "./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js"); 1737 1738var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray */ "./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"); 1739 1740var nonIterableRest = __webpack_require__(/*! ./nonIterableRest */ "./node_modules/@babel/runtime/helpers/nonIterableRest.js"); 1741 1742function _slicedToArray(arr, i) { 1743 return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest(); 1744} 1745 1746module.exports = _slicedToArray; 1747 1748/***/ }), 1749
vendor: 1,134 bytes, lines 1750-1772
1750/***/ "./node_modules/@babel/runtime/helpers/toConsumableArray.js": 1751/*!******************************************************************!*\ 1752 !*** ./node_modules/@babel/runtime/helpers/toConsumableArray.js ***! 1753 \******************************************************************/ 1754/*! no static exports found */ 1755/***/ (function(module, exports, __webpack_require__) { 1756 1757var arrayWithoutHoles = __webpack_require__(/*! ./arrayWithoutHoles */ "./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js"); 1758 1759var iterableToArray = __webpack_require__(/*! ./iterableToArray */ "./node_modules/@babel/runtime/helpers/iterableToArray.js"); 1760 1761var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray */ "./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"); 1762 1763var nonIterableSpread = __webpack_require__(/*! ./nonIterableSpread */ "./node_modules/@babel/runtime/helpers/nonIterableSpread.js"); 1764 1765function _toConsumableArray(arr) { 1766 return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread(); 1767} 1768 1769module.exports = _toConsumableArray; 1770 1771/***/ }), 1772
vendor: 1,025 bytes, lines 1773-1794
1773/***/ "./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js": 1774/*!***************************************************************************!*\ 1775 !*** ./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js ***! 1776 \***************************************************************************/ 1777/*! no static exports found */ 1778/***/ (function(module, exports, __webpack_require__) { 1779 1780var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray */ "./node_modules/@babel/runtime/helpers/arrayLikeToArray.js"); 1781 1782function _unsupportedIterableToArray(o, minLen) { 1783 if (!o) return; 1784 if (typeof o === "string") return arrayLikeToArray(o, minLen); 1785 var n = Object.prototype.toString.call(o).slice(8, -1); 1786 if (n === "Object" && o.constructor) n = o.constructor.name; 1787 if (n === "Map" || n === "Set") return Array.from(o); 1788 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen); 1789} 1790 1791module.exports = _unsupportedIterableToArray; 1792 1793/***/ }), 1794
vendor: 465 bytes, lines 1795-1805
1795/***/ "./node_modules/@babel/runtime/regenerator/index.js": 1796/*!**********************************************************!*\ 1797 !*** ./node_modules/@babel/runtime/regenerator/index.js ***! 1798 \**********************************************************/ 1799/*! no static exports found */ 1800/***/ (function(module, exports, __webpack_require__) { 1801 1802module.exports = __webpack_require__(/*! regenerator-runtime */ "./node_modules/regenerator-runtime/runtime.js"); 1803 1804/***/ }), 1805
vendor: 438 bytes, lines 1806-1816
1806/***/ "./node_modules/es6-promise-promise/index.js": 1807/*!***************************************************!*\ 1808 !*** ./node_modules/es6-promise-promise/index.js ***! 1809 \***************************************************/ 1810/*! no static exports found */ 1811/***/ (function(module, exports, __webpack_require__) { 1812 1813module.exports = __webpack_require__(/*! es6-promise */ "./node_modules/es6-promise/dist/es6-promise.js").Promise; 1814 1815/***/ }), 1816
vendor: 31,757 bytes, lines 1817-2993
1817/***/ "./node_modules/es6-promise/dist/es6-promise.js": 1818/*!******************************************************!*\ 1819 !*** ./node_modules/es6-promise/dist/es6-promise.js ***! 1820 \******************************************************/ 1821/*! no static exports found */ 1822/***/ (function(module, exports, __webpack_require__) { 1823 1824/* WEBPACK VAR INJECTION */(function(process, global) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;var require;function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } 1825 1826/*! 1827 * @overview es6-promise - a tiny implementation of Promises/A+. 1828 * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald) 1829 * @license Licensed under MIT license 1830 * See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE 1831 * @version 3.3.1 1832 */ 1833(function (global, factory) { 1834 ( false ? undefined : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : true ? !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 1835 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 1836 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 1837 __WEBPACK_AMD_DEFINE_FACTORY__), 1838 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : undefined; 1839})(this, function () { 1840 'use strict'; 1841 1842 function objectOrFunction(x) { 1843 return typeof x === 'function' || _typeof(x) === 'object' && x !== null; 1844 } 1845 1846 function isFunction(x) { 1847 return typeof x === 'function'; 1848 } 1849 1850 var _isArray = undefined; 1851 1852 if (!Array.isArray) { 1853 _isArray = function _isArray(x) { 1854 return Object.prototype.toString.call(x) === '[object Array]'; 1855 }; 1856 } else { 1857 _isArray = Array.isArray; 1858 } 1859 1860 var isArray = _isArray; 1861 var len = 0; 1862 var vertxNext = undefined; 1863 var customSchedulerFn = undefined; 1864 1865 var asap = function asap(callback, arg) { 1866 queue[len] = callback; 1867 queue[len + 1] = arg; 1868 len += 2; 1869 1870 if (len === 2) { 1871 // If len is 2, that means that we need to schedule an async flush. 1872 // If additional callbacks are queued before the queue is flushed, they 1873 // will be processed by this flush that we are scheduling. 1874 if (customSchedulerFn) { 1875 customSchedulerFn(flush); 1876 } else { 1877 scheduleFlush(); 1878 } 1879 } 1880 }; 1881 1882 function setScheduler(scheduleFn) { 1883 customSchedulerFn = scheduleFn; 1884 } 1885 1886 function setAsap(asapFn) { 1887 asap = asapFn; 1888 } 1889 1890 var browserWindow = typeof window !== 'undefined' ? window : undefined; 1891 var browserGlobal = browserWindow || {}; 1892 var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; 1893 var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]'; // test for web worker but not in IE10 1894 1895 var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined'; // node 1896 1897 function useNextTick() { 1898 // node version 0.10.x displays a deprecation warning when nextTick is used recursively 1899 // see https://github.com/cujojs/when/issues/410 for details 1900 return function () { 1901 return process.nextTick(flush); 1902 }; 1903 } // vertx 1904 1905 1906 function useVertxTimer() { 1907 return function () { 1908 vertxNext(flush); 1909 }; 1910 } 1911 1912 function useMutationObserver() { 1913 var iterations = 0; 1914 var observer = new BrowserMutationObserver(flush); 1915 var node = document.createTextNode(''); 1916 observer.observe(node, { 1917 characterData: true 1918 }); 1919 return function () { 1920 node.data = iterations = ++iterations % 2; 1921 }; 1922 } // web worker 1923 1924 1925 function useMessageChannel() { 1926 var channel = new MessageChannel(); 1927 channel.port1.onmessage = flush; 1928 return function () { 1929 return channel.port2.postMessage(0); 1930 }; 1931 } 1932 1933 function useSetTimeout() { 1934 // Store setTimeout reference so es6-promise will be unaffected by 1935 // other code modifying setTimeout (like sinon.useFakeTimers()) 1936 var globalSetTimeout = setTimeout; 1937 return function () { 1938 return globalSetTimeout(flush, 1); 1939 }; 1940 } 1941 1942 var queue = new Array(1000); 1943 1944 function flush() { 1945 for (var i = 0; i < len; i += 2) { 1946 var callback = queue[i]; 1947 var arg = queue[i + 1]; 1948 callback(arg); 1949 queue[i] = undefined; 1950 queue[i + 1] = undefined; 1951 } 1952 1953 len = 0; 1954 } 1955 1956 function attemptVertx() { 1957 try { 1958 var r = require; 1959 var vertx = __webpack_require__(/*! vertx */ 1); 1960 vertxNext = vertx.runOnLoop || vertx.runOnContext; 1961 return useVertxTimer(); 1962 } catch (e) { 1963 return useSetTimeout(); 1964 } 1965 } 1966 1967 var scheduleFlush = undefined; // Decide what async method to use to triggering processing of queued callbacks: 1968 1969 if (isNode) { 1970 scheduleFlush = useNextTick(); 1971 } else if (BrowserMutationObserver) { 1972 scheduleFlush = useMutationObserver(); 1973 } else if (isWorker) { 1974 scheduleFlush = useMessageChannel(); 1975 } else if (browserWindow === undefined && "function" === 'function') { 1976 scheduleFlush = attemptVertx(); 1977 } else { 1978 scheduleFlush = useSetTimeout(); 1979 } 1980 1981 function then(onFulfillment, onRejection) { 1982 var _arguments = arguments; 1983 var parent = this; 1984 var child = new this.constructor(noop); 1985 1986 if (child[PROMISE_ID] === undefined) { 1987 makePromise(child); 1988 } 1989 1990 var _state = parent._state; 1991 1992 if (_state) { 1993 (function () { 1994 var callback = _arguments[_state - 1]; 1995 asap(function () { 1996 return invokeCallback(_state, child, callback, parent._result); 1997 }); 1998 })(); 1999 } else { 2000 subscribe(parent, child, onFulfillment, onRejection); 2001 } 2002 2003 return child; 2004 } 2005 /** 2006 `Promise.resolve` returns a promise that will become resolved with the 2007 passed `value`. It is shorthand for the following: 2008 2009 ```javascript 2010 let promise = new Promise(function(resolve, reject){ 2011 resolve(1); 2012 }); 2013 2014 promise.then(function(value){ 2015 // value === 1 2016 }); 2017 ``` 2018 2019 Instead of writing the above, your code now simply becomes the following: 2020 2021 ```javascript 2022 let promise = Promise.resolve(1); 2023 2024 promise.then(function(value){ 2025 // value === 1 2026 }); 2027 ``` 2028 2029 @method resolve 2030 @static 2031 @param {Any} value value that the returned promise will be resolved with 2032 Useful for tooling. 2033 @return {Promise} a promise that will become fulfilled with the given 2034 `value` 2035 */ 2036 2037 2038 function resolve(object) { 2039 /*jshint validthis:true */ 2040 var Constructor = this; 2041 2042 if (object && _typeof(object) === 'object' && object.constructor === Constructor) { 2043 return object; 2044 } 2045 2046 var promise = new Constructor(noop); 2047 2048 _resolve(promise, object); 2049 2050 return promise; 2051 } 2052 2053 var PROMISE_ID = Math.random().toString(36).substring(16); 2054 2055 function noop() {} 2056 2057 var PENDING = void 0; 2058 var FULFILLED = 1; 2059 var REJECTED = 2; 2060 var GET_THEN_ERROR = new ErrorObject(); 2061 2062 function selfFulfillment() { 2063 return new TypeError("You cannot resolve a promise with itself"); 2064 } 2065 2066 function cannotReturnOwn() { 2067 return new TypeError('A promises callback cannot return that same promise.'); 2068 } 2069 2070 function getThen(promise) { 2071 try { 2072 return promise.then; 2073 } catch (error) { 2074 GET_THEN_ERROR.error = error; 2075 return GET_THEN_ERROR; 2076 } 2077 } 2078 2079 function tryThen(then, value, fulfillmentHandler, rejectionHandler) { 2080 try { 2081 then.call(value, fulfillmentHandler, rejectionHandler); 2082 } catch (e) { 2083 return e; 2084 } 2085 } 2086 2087 function handleForeignThenable(promise, thenable, then) { 2088 asap(function (promise) { 2089 var sealed = false; 2090 var error = tryThen(then, thenable, function (value) { 2091 if (sealed) { 2092 return; 2093 } 2094 2095 sealed = true; 2096 2097 if (thenable !== value) { 2098 _resolve(promise, value); 2099 } else { 2100 fulfill(promise, value); 2101 } 2102 }, function (reason) { 2103 if (sealed) { 2104 return; 2105 } 2106 2107 sealed = true; 2108 2109 _reject(promise, reason); 2110 }, 'Settle: ' + (promise._label || ' unknown promise')); 2111 2112 if (!sealed && error) { 2113 sealed = true; 2114 2115 _reject(promise, error); 2116 } 2117 }, promise); 2118 } 2119 2120 function handleOwnThenable(promise, thenable) { 2121 if (thenable._state === FULFILLED) { 2122 fulfill(promise, thenable._result); 2123 } else if (thenable._state === REJECTED) { 2124 _reject(promise, thenable._result); 2125 } else { 2126 subscribe(thenable, undefined, function (value) { 2127 return _resolve(promise, value); 2128 }, function (reason) { 2129 return _reject(promise, reason); 2130 }); 2131 } 2132 } 2133 2134 function handleMaybeThenable(promise, maybeThenable, then$$) { 2135 if (maybeThenable.constructor === promise.constructor && then$$ === then && maybeThenable.constructor.resolve === resolve) { 2136 handleOwnThenable(promise, maybeThenable); 2137 } else { 2138 if (then$$ === GET_THEN_ERROR) { 2139 _reject(promise, GET_THEN_ERROR.error); 2140 } else if (then$$ === undefined) { 2141 fulfill(promise, maybeThenable); 2142 } else if (isFunction(then$$)) { 2143 handleForeignThenable(promise, maybeThenable, then$$); 2144 } else { 2145 fulfill(promise, maybeThenable); 2146 } 2147 } 2148 } 2149 2150 function _resolve(promise, value) { 2151 if (promise === value) { 2152 _reject(promise, selfFulfillment()); 2153 } else if (objectOrFunction(value)) { 2154 handleMaybeThenable(promise, value, getThen(value)); 2155 } else { 2156 fulfill(promise, value); 2157 } 2158 } 2159 2160 function publishRejection(promise) { 2161 if (promise._onerror) { 2162 promise._onerror(promise._result); 2163 } 2164 2165 publish(promise); 2166 } 2167 2168 function fulfill(promise, value) { 2169 if (promise._state !== PENDING) { 2170 return; 2171 } 2172 2173 promise._result = value; 2174 promise._state = FULFILLED; 2175 2176 if (promise._subscribers.length !== 0) { 2177 asap(publish, promise); 2178 } 2179 } 2180 2181 function _reject(promise, reason) { 2182 if (promise._state !== PENDING) { 2183 return; 2184 } 2185 2186 promise._state = REJECTED; 2187 promise._result = reason; 2188 asap(publishRejection, promise); 2189 } 2190 2191 function subscribe(parent, child, onFulfillment, onRejection) { 2192 var _subscribers = parent._subscribers; 2193 var length = _subscribers.length; 2194 parent._onerror = null; 2195 _subscribers[length] = child; 2196 _subscribers[length + FULFILLED] = onFulfillment; 2197 _subscribers[length + REJECTED] = onRejection; 2198 2199 if (length === 0 && parent._state) { 2200 asap(publish, parent); 2201 } 2202 } 2203 2204 function publish(promise) { 2205 var subscribers = promise._subscribers; 2206 var settled = promise._state; 2207 2208 if (subscribers.length === 0) { 2209 return; 2210 } 2211 2212 var child = undefined, 2213 callback = undefined, 2214 detail = promise._result; 2215 2216 for (var i = 0; i < subscribers.length; i += 3) { 2217 child = subscribers[i]; 2218 callback = subscribers[i + settled]; 2219 2220 if (child) { 2221 invokeCallback(settled, child, callback, detail); 2222 } else { 2223 callback(detail); 2224 } 2225 } 2226 2227 promise._subscribers.length = 0; 2228 } 2229 2230 function ErrorObject() { 2231 this.error = null; 2232 } 2233 2234 var TRY_CATCH_ERROR = new ErrorObject(); 2235 2236 function tryCatch(callback, detail) { 2237 try { 2238 return callback(detail); 2239 } catch (e) { 2240 TRY_CATCH_ERROR.error = e; 2241 return TRY_CATCH_ERROR; 2242 } 2243 } 2244 2245 function invokeCallback(settled, promise, callback, detail) { 2246 var hasCallback = isFunction(callback), 2247 value = undefined, 2248 error = undefined, 2249 succeeded = undefined, 2250 failed = undefined; 2251 2252 if (hasCallback) { 2253 value = tryCatch(callback, detail); 2254 2255 if (value === TRY_CATCH_ERROR) { 2256 failed = true; 2257 error = value.error; 2258 value = null; 2259 } else { 2260 succeeded = true; 2261 } 2262 2263 if (promise === value) { 2264 _reject(promise, cannotReturnOwn()); 2265 2266 return; 2267 } 2268 } else { 2269 value = detail; 2270 succeeded = true; 2271 } 2272 2273 if (promise._state !== PENDING) {// noop 2274 } else if (hasCallback && succeeded) { 2275 _resolve(promise, value); 2276 } else if (failed) { 2277 _reject(promise, error); 2278 } else if (settled === FULFILLED) { 2279 fulfill(promise, value); 2280 } else if (settled === REJECTED) { 2281 _reject(promise, value); 2282 } 2283 } 2284 2285 function initializePromise(promise, resolver) { 2286 try { 2287 resolver(function resolvePromise(value) { 2288 _resolve(promise, value); 2289 }, function rejectPromise(reason) { 2290 _reject(promise, reason); 2291 }); 2292 } catch (e) { 2293 _reject(promise, e); 2294 } 2295 } 2296 2297 var id = 0; 2298 2299 function nextId() { 2300 return id++; 2301 } 2302 2303 function makePromise(promise) { 2304 promise[PROMISE_ID] = id++; 2305 promise._state = undefined; 2306 promise._result = undefined; 2307 promise._subscribers = []; 2308 } 2309 2310 function Enumerator(Constructor, input) { 2311 this._instanceConstructor = Constructor; 2312 this.promise = new Constructor(noop); 2313 2314 if (!this.promise[PROMISE_ID]) { 2315 makePromise(this.promise); 2316 } 2317 2318 if (isArray(input)) { 2319 this._input = input; 2320 this.length = input.length; 2321 this._remaining = input.length; 2322 this._result = new Array(this.length); 2323 2324 if (this.length === 0) { 2325 fulfill(this.promise, this._result); 2326 } else { 2327 this.length = this.length || 0; 2328 2329 this._enumerate(); 2330 2331 if (this._remaining === 0) { 2332 fulfill(this.promise, this._result); 2333 } 2334 } 2335 } else { 2336 _reject(this.promise, validationError()); 2337 } 2338 } 2339 2340 function validationError() { 2341 return new Error('Array Methods must be provided an Array'); 2342 } 2343 2344 ; 2345 2346 Enumerator.prototype._enumerate = function () { 2347 var length = this.length; 2348 var _input = this._input; 2349 2350 for (var i = 0; this._state === PENDING && i < length; i++) { 2351 this._eachEntry(_input[i], i); 2352 } 2353 }; 2354 2355 Enumerator.prototype._eachEntry = function (entry, i) { 2356 var c = this._instanceConstructor; 2357 var resolve$$ = c.resolve; 2358 2359 if (resolve$$ === resolve) { 2360 var _then = getThen(entry); 2361 2362 if (_then === then && entry._state !== PENDING) { 2363 this._settledAt(entry._state, i, entry._result); 2364 } else if (typeof _then !== 'function') { 2365 this._remaining--; 2366 this._result[i] = entry; 2367 } else if (c === Promise) { 2368 var promise = new c(noop); 2369 handleMaybeThenable(promise, entry, _then); 2370 2371 this._willSettleAt(promise, i); 2372 } else { 2373 this._willSettleAt(new c(function (resolve$$) { 2374 return resolve$$(entry); 2375 }), i); 2376 } 2377 } else { 2378 this._willSettleAt(resolve$$(entry), i); 2379 } 2380 }; 2381 2382 Enumerator.prototype._settledAt = function (state, i, value) { 2383 var promise = this.promise; 2384 2385 if (promise._state === PENDING) { 2386 this._remaining--; 2387 2388 if (state === REJECTED) { 2389 _reject(promise, value); 2390 } else { 2391 this._result[i] = value; 2392 } 2393 } 2394 2395 if (this._remaining === 0) { 2396 fulfill(promise, this._result); 2397 } 2398 }; 2399 2400 Enumerator.prototype._willSettleAt = function (promise, i) { 2401 var enumerator = this; 2402 subscribe(promise, undefined, function (value) { 2403 return enumerator._settledAt(FULFILLED, i, value); 2404 }, function (reason) { 2405 return enumerator._settledAt(REJECTED, i, reason); 2406 }); 2407 }; 2408 /** 2409 `Promise.all` accepts an array of promises, and returns a new promise which 2410 is fulfilled with an array of fulfillment values for the passed promises, or 2411 rejected with the reason of the first passed promise to be rejected. It casts all 2412 elements of the passed iterable to promises as it runs this algorithm. 2413 2414 Example: 2415 2416 ```javascript 2417 let promise1 = resolve(1); 2418 let promise2 = resolve(2); 2419 let promise3 = resolve(3); 2420 let promises = [ promise1, promise2, promise3 ]; 2421 2422 Promise.all(promises).then(function(array){ 2423 // The array here would be [ 1, 2, 3 ]; 2424 }); 2425 ``` 2426 2427 If any of the `promises` given to `all` are rejected, the first promise 2428 that is rejected will be given as an argument to the returned promises's 2429 rejection handler. For example: 2430 2431 Example: 2432 2433 ```javascript 2434 let promise1 = resolve(1); 2435 let promise2 = reject(new Error("2")); 2436 let promise3 = reject(new Error("3")); 2437 let promises = [ promise1, promise2, promise3 ]; 2438 2439 Promise.all(promises).then(function(array){ 2440 // Code here never runs because there are rejected promises! 2441 }, function(error) { 2442 // error.message === "2" 2443 }); 2444 ``` 2445 2446 @method all 2447 @static 2448 @param {Array} entries array of promises 2449 @param {String} label optional string for labeling the promise. 2450 Useful for tooling. 2451 @return {Promise} promise that is fulfilled when all `promises` have been 2452 fulfilled, or rejected if any of them become rejected. 2453 @static 2454 */ 2455 2456 2457 function all(entries) { 2458 return new Enumerator(this, entries).promise; 2459 } 2460 /** 2461 `Promise.race` returns a new promise which is settled in the same way as the 2462 first passed promise to settle. 2463 2464 Example: 2465 2466 ```javascript 2467 let promise1 = new Promise(function(resolve, reject){ 2468 setTimeout(function(){ 2469 resolve('promise 1'); 2470 }, 200); 2471 }); 2472 2473 let promise2 = new Promise(function(resolve, reject){ 2474 setTimeout(function(){ 2475 resolve('promise 2'); 2476 }, 100); 2477 }); 2478 2479 Promise.race([promise1, promise2]).then(function(result){ 2480 // result === 'promise 2' because it was resolved before promise1 2481 // was resolved. 2482 }); 2483 ``` 2484 2485 `Promise.race` is deterministic in that only the state of the first 2486 settled promise matters. For example, even if other promises given to the 2487 `promises` array argument are resolved, but the first settled promise has 2488 become rejected before the other promises became fulfilled, the returned 2489 promise will become rejected: 2490 2491 ```javascript 2492 let promise1 = new Promise(function(resolve, reject){ 2493 setTimeout(function(){ 2494 resolve('promise 1'); 2495 }, 200); 2496 }); 2497 2498 let promise2 = new Promise(function(resolve, reject){ 2499 setTimeout(function(){ 2500 reject(new Error('promise 2')); 2501 }, 100); 2502 }); 2503 2504 Promise.race([promise1, promise2]).then(function(result){ 2505 // Code here never runs 2506 }, function(reason){ 2507 // reason.message === 'promise 2' because promise 2 became rejected before 2508 // promise 1 became fulfilled 2509 }); 2510 ``` 2511 2512 An example real-world use case is implementing timeouts: 2513 2514 ```javascript 2515 Promise.race([ajax('foo.json'), timeout(5000)]) 2516 ``` 2517 2518 @method race 2519 @static 2520 @param {Array} promises array of promises to observe 2521 Useful for tooling. 2522 @return {Promise} a promise which settles in the same way as the first passed 2523 promise to settle. 2524 */ 2525 2526 2527 function race(entries) { 2528 /*jshint validthis:true */ 2529 var Constructor = this; 2530 2531 if (!isArray(entries)) { 2532 return new Constructor(function (_, reject) { 2533 return reject(new TypeError('You must pass an array to race.')); 2534 }); 2535 } else { 2536 return new Constructor(function (resolve, reject) { 2537 var length = entries.length; 2538 2539 for (var i = 0; i < length; i++) { 2540 Constructor.resolve(entries[i]).then(resolve, reject); 2541 } 2542 }); 2543 } 2544 } 2545 /** 2546 `Promise.reject` returns a promise rejected with the passed `reason`. 2547 It is shorthand for the following: 2548 2549 ```javascript 2550 let promise = new Promise(function(resolve, reject){ 2551 reject(new Error('WHOOPS')); 2552 }); 2553 2554 promise.then(function(value){ 2555 // Code here doesn't run because the promise is rejected! 2556 }, function(reason){ 2557 // reason.message === 'WHOOPS' 2558 }); 2559 ``` 2560 2561 Instead of writing the above, your code now simply becomes the following: 2562 2563 ```javascript 2564 let promise = Promise.reject(new Error('WHOOPS')); 2565 2566 promise.then(function(value){ 2567 // Code here doesn't run because the promise is rejected! 2568 }, function(reason){ 2569 // reason.message === 'WHOOPS' 2570 }); 2571 ``` 2572 2573 @method reject 2574 @static 2575 @param {Any} reason value that the returned promise will be rejected with. 2576 Useful for tooling. 2577 @return {Promise} a promise rejected with the given `reason`. 2578 */ 2579 2580 2581 function reject(reason) { 2582 /*jshint validthis:true */ 2583 var Constructor = this; 2584 var promise = new Constructor(noop); 2585 2586 _reject(promise, reason); 2587 2588 return promise; 2589 } 2590 2591 function needsResolver() { 2592 throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); 2593 } 2594 2595 function needsNew() { 2596 throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."); 2597 } 2598 /** 2599 Promise objects represent the eventual result of an asynchronous operation. The 2600 primary way of interacting with a promise is through its `then` method, which 2601 registers callbacks to receive either a promise's eventual value or the reason 2602 why the promise cannot be fulfilled. 2603 2604 Terminology 2605 ----------- 2606 2607 - `promise` is an object or function with a `then` method whose behavior conforms to this specification. 2608 - `thenable` is an object or function that defines a `then` method. 2609 - `value` is any legal JavaScript value (including undefined, a thenable, or a promise). 2610 - `exception` is a value that is thrown using the throw statement. 2611 - `reason` is a value that indicates why a promise was rejected. 2612 - `settled` the final resting state of a promise, fulfilled or rejected. 2613 2614 A promise can be in one of three states: pending, fulfilled, or rejected. 2615 2616 Promises that are fulfilled have a fulfillment value and are in the fulfilled 2617 state. Promises that are rejected have a rejection reason and are in the 2618 rejected state. A fulfillment value is never a thenable. 2619 2620 Promises can also be said to *resolve* a value. If this value is also a 2621 promise, then the original promise's settled state will match the value's 2622 settled state. So a promise that *resolves* a promise that rejects will 2623 itself reject, and a promise that *resolves* a promise that fulfills will 2624 itself fulfill. 2625 2626 2627 Basic Usage: 2628 ------------ 2629 2630 ```js 2631 let promise = new Promise(function(resolve, reject) { 2632 // on success 2633 resolve(value); 2634 2635 // on failure 2636 reject(reason); 2637 }); 2638 2639 promise.then(function(value) { 2640 // on fulfillment 2641 }, function(reason) { 2642 // on rejection 2643 }); 2644 ``` 2645 2646 Advanced Usage: 2647 --------------- 2648 2649 Promises shine when abstracting away asynchronous interactions such as 2650 `XMLHttpRequest`s. 2651 2652 ```js 2653 function getJSON(url) { 2654 return new Promise(function(resolve, reject){ 2655 let xhr = new XMLHttpRequest(); 2656 2657 xhr.open('GET', url); 2658 xhr.onreadystatechange = handler; 2659 xhr.responseType = 'json'; 2660 xhr.setRequestHeader('Accept', 'application/json'); 2661 xhr.send(); 2662 2663 function handler() { 2664 if (this.readyState === this.DONE) { 2665 if (this.status === 200) { 2666 resolve(this.response); 2667 } else { 2668 reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']')); 2669 } 2670 } 2671 }; 2672 }); 2673 } 2674 2675 getJSON('/posts.json').then(function(json) { 2676 // on fulfillment 2677 }, function(reason) { 2678 // on rejection 2679 }); 2680 ``` 2681 2682 Unlike callbacks, promises are great composable primitives. 2683 2684 ```js 2685 Promise.all([ 2686 getJSON('/posts'), 2687 getJSON('/comments') 2688 ]).then(function(values){ 2689 values[0] // => postsJSON 2690 values[1] // => commentsJSON 2691 2692 return values; 2693 }); 2694 ``` 2695 2696 @class Promise 2697 @param {function} resolver 2698 Useful for tooling. 2699 @constructor 2700 */ 2701 2702 2703 function Promise(resolver) { 2704 this[PROMISE_ID] = nextId(); 2705 this._result = this._state = undefined; 2706 this._subscribers = []; 2707 2708 if (noop !== resolver) { 2709 typeof resolver !== 'function' && needsResolver(); 2710 this instanceof Promise ? initializePromise(this, resolver) : needsNew(); 2711 } 2712 } 2713 2714 Promise.all = all; 2715 Promise.race = race; 2716 Promise.resolve = resolve; 2717 Promise.reject = reject; 2718 Promise._setScheduler = setScheduler; 2719 Promise._setAsap = setAsap; 2720 Promise._asap = asap; 2721 Promise.prototype = { 2722 constructor: Promise, 2723 2724 /** 2725 The primary way of interacting with a promise is through its `then` method, 2726 which registers callbacks to receive either a promise's eventual value or the 2727 reason why the promise cannot be fulfilled. 2728 2729 ```js 2730 findUser().then(function(user){ 2731 // user is available 2732 }, function(reason){ 2733 // user is unavailable, and you are given the reason why 2734 }); 2735 ``` 2736 2737 Chaining 2738 -------- 2739 2740 The return value of `then` is itself a promise. This second, 'downstream' 2741 promise is resolved with the return value of the first promise's fulfillment 2742 or rejection handler, or rejected if the handler throws an exception. 2743 2744 ```js 2745 findUser().then(function (user) { 2746 return user.name; 2747 }, function (reason) { 2748 return 'default name'; 2749 }).then(function (userName) { 2750 // If `findUser` fulfilled, `userName` will be the user's name, otherwise it 2751 // will be `'default name'` 2752 }); 2753 2754 findUser().then(function (user) { 2755 throw new Error('Found user, but still unhappy'); 2756 }, function (reason) { 2757 throw new Error('`findUser` rejected and we're unhappy'); 2758 }).then(function (value) { 2759 // never reached 2760 }, function (reason) { 2761 // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'. 2762 // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'. 2763 }); 2764 ``` 2765 If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream. 2766 2767 ```js 2768 findUser().then(function (user) { 2769 throw new PedagogicalException('Upstream error'); 2770 }).then(function (value) { 2771 // never reached 2772 }).then(function (value) { 2773 // never reached 2774 }, function (reason) { 2775 // The `PedgagocialException` is propagated all the way down to here 2776 }); 2777 ``` 2778 2779 Assimilation 2780 ------------ 2781 2782 Sometimes the value you want to propagate to a downstream promise can only be 2783 retrieved asynchronously. This can be achieved by returning a promise in the 2784 fulfillment or rejection handler. The downstream promise will then be pending 2785 until the returned promise is settled. This is called *assimilation*. 2786 2787 ```js 2788 findUser().then(function (user) { 2789 return findCommentsByAuthor(user); 2790 }).then(function (comments) { 2791 // The user's comments are now available 2792 }); 2793 ``` 2794 2795 If the assimliated promise rejects, then the downstream promise will also reject. 2796 2797 ```js 2798 findUser().then(function (user) { 2799 return findCommentsByAuthor(user); 2800 }).then(function (comments) { 2801 // If `findCommentsByAuthor` fulfills, we'll have the value here 2802 }, function (reason) { 2803 // If `findCommentsByAuthor` rejects, we'll have the reason here 2804 }); 2805 ``` 2806 2807 Simple Example 2808 -------------- 2809 2810 Synchronous Example 2811 2812 ```javascript 2813 let result; 2814 2815 try { 2816 result = findResult(); 2817 // success 2818 } catch(reason) { 2819 // failure 2820 } 2821 ``` 2822 2823 Errback Example 2824 2825 ```js 2826 findResult(function(result, err){ 2827 if (err) { 2828 // failure 2829 } else { 2830 // success 2831 } 2832 }); 2833 ``` 2834 2835 Promise Example; 2836 2837 ```javascript 2838 findResult().then(function(result){ 2839 // success 2840 }, function(reason){ 2841 // failure 2842 }); 2843 ``` 2844 2845 Advanced Example 2846 -------------- 2847 2848 Synchronous Example 2849 2850 ```javascript 2851 let author, books; 2852 2853 try { 2854 author = findAuthor(); 2855 books = findBooksByAuthor(author); 2856 // success 2857 } catch(reason) { 2858 // failure 2859 } 2860 ``` 2861 2862 Errback Example 2863 2864 ```js 2865 2866 function foundBooks(books) { 2867 2868 } 2869 2870 function failure(reason) { 2871 2872 } 2873 2874 findAuthor(function(author, err){ 2875 if (err) { 2876 failure(err); 2877 // failure 2878 } else { 2879 try { 2880 findBoooksByAuthor(author, function(books, err) { 2881 if (err) { 2882 failure(err); 2883 } else { 2884 try { 2885 foundBooks(books); 2886 } catch(reason) { 2887 failure(reason); 2888 } 2889 } 2890 }); 2891 } catch(error) { 2892 failure(err); 2893 } 2894 // success 2895 } 2896 }); 2897 ``` 2898 2899 Promise Example; 2900 2901 ```javascript 2902 findAuthor(). 2903 then(findBooksByAuthor). 2904 then(function(books){ 2905 // found books 2906 }).catch(function(reason){ 2907 // something went wrong 2908 }); 2909 ``` 2910 2911 @method then 2912 @param {Function} onFulfilled 2913 @param {Function} onRejected 2914 Useful for tooling. 2915 @return {Promise} 2916 */ 2917 then: then, 2918 2919 /** 2920 `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same 2921 as the catch block of a try/catch statement. 2922 2923 ```js 2924 function findAuthor(){ 2925 throw new Error('couldn't find that author'); 2926 } 2927 2928 // synchronous 2929 try { 2930 findAuthor(); 2931 } catch(reason) { 2932 // something went wrong 2933 } 2934 2935 // async with promises 2936 findAuthor().catch(function(reason){ 2937 // something went wrong 2938 }); 2939 ``` 2940 2941 @method catch 2942 @param {Function} onRejection 2943 Useful for tooling. 2944 @return {Promise} 2945 */ 2946 'catch': function _catch(onRejection) { 2947 return this.then(null, onRejection); 2948 } 2949 }; 2950 2951 function polyfill() { 2952 var local = undefined; 2953 2954 if (typeof global !== 'undefined') { 2955 local = global; 2956 } else if (typeof self !== 'undefined') { 2957 local = self; 2958 } else { 2959 try { 2960 local = Function('return this')(); 2961 } catch (e) { 2962 throw new Error('polyfill failed because global object is unavailable in this environment'); 2963 } 2964 } 2965 2966 var P = local.Promise; 2967 2968 if (P) { 2969 var promiseToString = null; 2970 2971 try { 2972 promiseToString = Object.prototype.toString.call(P.resolve()); 2973 } catch (e) {// silently ignored 2974 } 2975 2976 if (promiseToString === '[object Promise]' && !P.cast) { 2977 return; 2978 } 2979 } 2980 2981 local.Promise = Promise; 2982 } 2983 2984 polyfill(); // Strange compat.. 2985 2986 Promise.polyfill = polyfill; 2987 Promise.Promise = Promise; 2988 return Promise; 2989}); 2990/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js"), __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) 2991 2992/***/ }), 2993
vendor: 5,344 bytes, lines 2994-3211
2994/***/ "./node_modules/process/browser.js": 2995/*!*****************************************!*\ 2996 !*** ./node_modules/process/browser.js ***! 2997 \*****************************************/ 2998/*! no static exports found */ 2999/***/ (function(module, exports) { 3000 3001// shim for using process in browser 3002var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it 3003// don't break things. But we need to wrap it in a try catch in case it is 3004// wrapped in strict mode code which doesn't define any globals. It's inside a 3005// function because try/catches deoptimize in certain engines. 3006 3007var cachedSetTimeout; 3008var cachedClearTimeout; 3009 3010function defaultSetTimout() { 3011 throw new Error('setTimeout has not been defined'); 3012} 3013 3014function defaultClearTimeout() { 3015 throw new Error('clearTimeout has not been defined'); 3016} 3017 3018(function () { 3019 try { 3020 if (typeof setTimeout === 'function') { 3021 cachedSetTimeout = setTimeout; 3022 } else { 3023 cachedSetTimeout = defaultSetTimout; 3024 } 3025 } catch (e) { 3026 cachedSetTimeout = defaultSetTimout; 3027 } 3028 3029 try { 3030 if (typeof clearTimeout === 'function') { 3031 cachedClearTimeout = clearTimeout; 3032 } else { 3033 cachedClearTimeout = defaultClearTimeout; 3034 } 3035 } catch (e) { 3036 cachedClearTimeout = defaultClearTimeout; 3037 } 3038})(); 3039 3040function runTimeout(fun) { 3041 if (cachedSetTimeout === setTimeout) { 3042 //normal enviroments in sane situations 3043 return setTimeout(fun, 0); 3044 } // if setTimeout wasn't available but was latter defined 3045 3046 3047 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 3048 cachedSetTimeout = setTimeout; 3049 return setTimeout(fun, 0); 3050 } 3051 3052 try { 3053 // when when somebody has screwed with setTimeout but no I.E. maddness 3054 return cachedSetTimeout(fun, 0); 3055 } catch (e) { 3056 try { 3057 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 3058 return cachedSetTimeout.call(null, fun, 0); 3059 } catch (e) { 3060 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error 3061 return cachedSetTimeout.call(this, fun, 0); 3062 } 3063 } 3064} 3065 3066function runClearTimeout(marker) { 3067 if (cachedClearTimeout === clearTimeout) { 3068 //normal enviroments in sane situations 3069 return clearTimeout(marker); 3070 } // if clearTimeout wasn't available but was latter defined 3071 3072 3073 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 3074 cachedClearTimeout = clearTimeout; 3075 return clearTimeout(marker); 3076 } 3077 3078 try { 3079 // when when somebody has screwed with setTimeout but no I.E. maddness 3080 return cachedClearTimeout(marker); 3081 } catch (e) { 3082 try { 3083 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 3084 return cachedClearTimeout.call(null, marker); 3085 } catch (e) { 3086 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. 3087 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 3088 return cachedClearTimeout.call(this, marker); 3089 } 3090 } 3091} 3092 3093var queue = []; 3094var draining = false; 3095var currentQueue; 3096var queueIndex = -1; 3097 3098function cleanUpNextTick() { 3099 if (!draining || !currentQueue) { 3100 return; 3101 } 3102 3103 draining = false; 3104 3105 if (currentQueue.length) { 3106 queue = currentQueue.concat(queue); 3107 } else { 3108 queueIndex = -1; 3109 } 3110 3111 if (queue.length) { 3112 drainQueue(); 3113 } 3114} 3115 3116function drainQueue() { 3117 if (draining) { 3118 return; 3119 } 3120 3121 var timeout = runTimeout(cleanUpNextTick); 3122 draining = true; 3123 var len = queue.length; 3124 3125 while (len) { 3126 currentQueue = queue; 3127 queue = []; 3128 3129 while (++queueIndex < len) { 3130 if (currentQueue) { 3131 currentQueue[queueIndex].run(); 3132 } 3133 } 3134 3135 queueIndex = -1; 3136 len = queue.length; 3137 } 3138 3139 currentQueue = null; 3140 draining = false; 3141 runClearTimeout(timeout); 3142} 3143 3144process.nextTick = function (fun) { 3145 var args = new Array(arguments.length - 1); 3146 3147 if (arguments.length > 1) { 3148 for (var i = 1; i < arguments.length; i++) { 3149 args[i - 1] = arguments[i]; 3150 } 3151 } 3152 3153 queue.push(new Item(fun, args)); 3154 3155 if (queue.length === 1 && !draining) { 3156 runTimeout(drainQueue); 3157 } 3158}; // v8 likes predictible objects 3159 3160 3161function Item(fun, array) { 3162 this.fun = fun; 3163 this.array = array; 3164} 3165 3166Item.prototype.run = function () { 3167 this.fun.apply(null, this.array); 3168}; 3169 3170process.title = 'browser'; 3171process.browser = true; 3172process.env = {}; 3173process.argv = []; 3174process.version = ''; // empty string to avoid regexp issues 3175 3176process.versions = {}; 3177 3178function noop() {} 3179 3180process.on = noop; 3181process.addListener = noop; 3182process.once = noop; 3183process.off = noop; 3184process.removeListener = noop; 3185process.removeAllListeners = noop; 3186process.emit = noop; 3187process.prependListener = noop; 3188process.prependOnceListener = noop; 3189 3190process.listeners = function (name) { 3191 return []; 3192}; 3193 3194process.binding = function (name) { 3195 throw new Error('process.binding is not supported'); 3196}; 3197 3198process.cwd = function () { 3199 return '/'; 3200}; 3201 3202process.chdir = function (dir) { 3203 throw new Error('process.chdir is not supported'); 3204}; 3205 3206process.umask = function () { 3207 return 0; 3208}; 3209 3210/***/ }), 3211
vendor: 24,919 bytes, lines 3212-3930
3212/***/ "./node_modules/regenerator-runtime/runtime.js": 3213/*!*****************************************************!*\ 3214 !*** ./node_modules/regenerator-runtime/runtime.js ***! 3215 \*****************************************************/ 3216/*! no static exports found */ 3217/***/ (function(module, exports, __webpack_require__) { 3218 3219/* WEBPACK VAR INJECTION */(function(module) {function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } 3220 3221/** 3222 * Copyright (c) 2014-present, Facebook, Inc. 3223 * 3224 * This source code is licensed under the MIT license found in the 3225 * LICENSE file in the root directory of this source tree. 3226 */ 3227var runtime = function (exports) { 3228 "use strict"; 3229 3230 var Op = Object.prototype; 3231 var hasOwn = Op.hasOwnProperty; 3232 var undefined; // More compressible than void 0. 3233 3234 var $Symbol = typeof Symbol === "function" ? Symbol : {}; 3235 var iteratorSymbol = $Symbol.iterator || "@@iterator"; 3236 var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; 3237 var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; 3238 3239 function wrap(innerFn, outerFn, self, tryLocsList) { 3240 // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. 3241 var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; 3242 var generator = Object.create(protoGenerator.prototype); 3243 var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next, 3244 // .throw, and .return methods. 3245 3246 generator._invoke = makeInvokeMethod(innerFn, self, context); 3247 return generator; 3248 } 3249 3250 exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion 3251 // record like context.tryEntries[i].completion. This interface could 3252 // have been (and was previously) designed to take a closure to be 3253 // invoked without arguments, but in all the cases we care about we 3254 // already have an existing method we want to call, so there's no need 3255 // to create a new function object. We can even get away with assuming 3256 // the method takes exactly one argument, since that happens to be true 3257 // in every case, so we don't have to touch the arguments object. The 3258 // only additional allocation required is the completion record, which 3259 // has a stable shape and so hopefully should be cheap to allocate. 3260 3261 function tryCatch(fn, obj, arg) { 3262 try { 3263 return { 3264 type: "normal", 3265 arg: fn.call(obj, arg) 3266 }; 3267 } catch (err) { 3268 return { 3269 type: "throw", 3270 arg: err 3271 }; 3272 } 3273 } 3274 3275 var GenStateSuspendedStart = "suspendedStart"; 3276 var GenStateSuspendedYield = "suspendedYield"; 3277 var GenStateExecuting = "executing"; 3278 var GenStateCompleted = "completed"; // Returning this object from the innerFn has the same effect as 3279 // breaking out of the dispatch switch statement. 3280 3281 var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and 3282 // .constructor.prototype properties for functions that return Generator 3283 // objects. For full spec compliance, you may wish to configure your 3284 // minifier not to mangle the names of these two functions. 3285 3286 function Generator() {} 3287 3288 function GeneratorFunction() {} 3289 3290 function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that 3291 // don't natively support it. 3292 3293 3294 var IteratorPrototype = {}; 3295 3296 IteratorPrototype[iteratorSymbol] = function () { 3297 return this; 3298 }; 3299 3300 var getProto = Object.getPrototypeOf; 3301 var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); 3302 3303 if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { 3304 // This environment has a native %IteratorPrototype%; use it instead 3305 // of the polyfill. 3306 IteratorPrototype = NativeIteratorPrototype; 3307 } 3308 3309 var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); 3310 GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; 3311 GeneratorFunctionPrototype.constructor = GeneratorFunction; 3312 GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction"; // Helper for defining the .next, .throw, and .return methods of the 3313 // Iterator interface in terms of a single ._invoke method. 3314 3315 function defineIteratorMethods(prototype) { 3316 ["next", "throw", "return"].forEach(function (method) { 3317 prototype[method] = function (arg) { 3318 return this._invoke(method, arg); 3319 }; 3320 }); 3321 } 3322 3323 exports.isGeneratorFunction = function (genFun) { 3324 var ctor = typeof genFun === "function" && genFun.constructor; 3325 return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can 3326 // do is to check its .name property. 3327 (ctor.displayName || ctor.name) === "GeneratorFunction" : false; 3328 }; 3329 3330 exports.mark = function (genFun) { 3331 if (Object.setPrototypeOf) { 3332 Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); 3333 } else { 3334 genFun.__proto__ = GeneratorFunctionPrototype; 3335 3336 if (!(toStringTagSymbol in genFun)) { 3337 genFun[toStringTagSymbol] = "GeneratorFunction"; 3338 } 3339 } 3340 3341 genFun.prototype = Object.create(Gp); 3342 return genFun; 3343 }; // Within the body of any async function, `await x` is transformed to 3344 // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test 3345 // `hasOwn.call(value, "__await")` to determine if the yielded value is 3346 // meant to be awaited. 3347 3348 3349 exports.awrap = function (arg) { 3350 return { 3351 __await: arg 3352 }; 3353 }; 3354 3355 function AsyncIterator(generator, PromiseImpl) { 3356 function invoke(method, arg, resolve, reject) { 3357 var record = tryCatch(generator[method], generator, arg); 3358 3359 if (record.type === "throw") { 3360 reject(record.arg); 3361 } else { 3362 var result = record.arg; 3363 var value = result.value; 3364 3365 if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) { 3366 return PromiseImpl.resolve(value.__await).then(function (value) { 3367 invoke("next", value, resolve, reject); 3368 }, function (err) { 3369 invoke("throw", err, resolve, reject); 3370 }); 3371 } 3372 3373 return PromiseImpl.resolve(value).then(function (unwrapped) { 3374 // When a yielded Promise is resolved, its final value becomes 3375 // the .value of the Promise<{value,done}> result for the 3376 // current iteration. 3377 result.value = unwrapped; 3378 resolve(result); 3379 }, function (error) { 3380 // If a rejected Promise was yielded, throw the rejection back 3381 // into the async generator function so it can be handled there. 3382 return invoke("throw", error, resolve, reject); 3383 }); 3384 } 3385 } 3386 3387 var previousPromise; 3388 3389 function enqueue(method, arg) { 3390 function callInvokeWithMethodAndArg() { 3391 return new PromiseImpl(function (resolve, reject) { 3392 invoke(method, arg, resolve, reject); 3393 }); 3394 } 3395 3396 return previousPromise = // If enqueue has been called before, then we want to wait until 3397 // all previous Promises have been resolved before calling invoke, 3398 // so that results are always delivered in the correct order. If 3399 // enqueue has not been called before, then it is important to 3400 // call invoke immediately, without waiting on a callback to fire, 3401 // so that the async generator function has the opportunity to do 3402 // any necessary setup in a predictable way. This predictability 3403 // is why the Promise constructor synchronously invokes its 3404 // executor callback, and why async functions synchronously 3405 // execute code before the first await. Since we implement simple 3406 // async functions in terms of async generators, it is especially 3407 // important to get this right, even though it requires care. 3408 previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later 3409 // invocations of the iterator. 3410 callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); 3411 } // Define the unified helper method that is used to implement .next, 3412 // .throw, and .return (see defineIteratorMethods). 3413 3414 3415 this._invoke = enqueue; 3416 } 3417 3418 defineIteratorMethods(AsyncIterator.prototype); 3419 3420 AsyncIterator.prototype[asyncIteratorSymbol] = function () { 3421 return this; 3422 }; 3423 3424 exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of 3425 // AsyncIterator objects; they just return a Promise for the value of 3426 // the final result produced by the iterator. 3427 3428 exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { 3429 if (PromiseImpl === void 0) PromiseImpl = Promise; 3430 var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); 3431 return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator. 3432 : iter.next().then(function (result) { 3433 return result.done ? result.value : iter.next(); 3434 }); 3435 }; 3436 3437 function makeInvokeMethod(innerFn, self, context) { 3438 var state = GenStateSuspendedStart; 3439 return function invoke(method, arg) { 3440 if (state === GenStateExecuting) { 3441 throw new Error("Generator is already running"); 3442 } 3443 3444 if (state === GenStateCompleted) { 3445 if (method === "throw") { 3446 throw arg; 3447 } // Be forgiving, per 25.3.3.3.3 of the spec: 3448 // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume 3449 3450 3451 return doneResult(); 3452 } 3453 3454 context.method = method; 3455 context.arg = arg; 3456 3457 while (true) { 3458 var delegate = context.delegate; 3459 3460 if (delegate) { 3461 var delegateResult = maybeInvokeDelegate(delegate, context); 3462 3463 if (delegateResult) { 3464 if (delegateResult === ContinueSentinel) continue; 3465 return delegateResult; 3466 } 3467 } 3468 3469 if (context.method === "next") { 3470 // Setting context._sent for legacy support of Babel's 3471 // function.sent implementation. 3472 context.sent = context._sent = context.arg; 3473 } else if (context.method === "throw") { 3474 if (state === GenStateSuspendedStart) { 3475 state = GenStateCompleted; 3476 throw context.arg; 3477 } 3478 3479 context.dispatchException(context.arg); 3480 } else if (context.method === "return") { 3481 context.abrupt("return", context.arg); 3482 } 3483 3484 state = GenStateExecuting; 3485 var record = tryCatch(innerFn, self, context); 3486 3487 if (record.type === "normal") { 3488 // If an exception is thrown from innerFn, we leave state === 3489 // GenStateExecuting and loop back for another invocation. 3490 state = context.done ? GenStateCompleted : GenStateSuspendedYield; 3491 3492 if (record.arg === ContinueSentinel) { 3493 continue; 3494 } 3495 3496 return { 3497 value: record.arg, 3498 done: context.done 3499 }; 3500 } else if (record.type === "throw") { 3501 state = GenStateCompleted; // Dispatch the exception by looping back around to the 3502 // context.dispatchException(context.arg) call above. 3503 3504 context.method = "throw"; 3505 context.arg = record.arg; 3506 } 3507 } 3508 }; 3509 } // Call delegate.iterator[context.method](context.arg) and handle the 3510 // result, either by returning a { value, done } result from the 3511 // delegate iterator, or by modifying context.method and context.arg, 3512 // setting context.delegate to null, and returning the ContinueSentinel. 3513 3514 3515 function maybeInvokeDelegate(delegate, context) { 3516 var method = delegate.iterator[context.method]; 3517 3518 if (method === undefined) { 3519 // A .throw or .return when the delegate iterator has no .throw 3520 // method always terminates the yield* loop. 3521 context.delegate = null; 3522 3523 if (context.method === "throw") { 3524 // Note: ["return"] must be used for ES3 parsing compatibility. 3525 if (delegate.iterator["return"]) { 3526 // If the delegate iterator has a return method, give it a 3527 // chance to clean up. 3528 context.method = "return"; 3529 context.arg = undefined; 3530 maybeInvokeDelegate(delegate, context); 3531 3532 if (context.method === "throw") { 3533 // If maybeInvokeDelegate(context) changed context.method from 3534 // "return" to "throw", let that override the TypeError below. 3535 return ContinueSentinel; 3536 } 3537 } 3538 3539 context.method = "throw"; 3540 context.arg = new TypeError("The iterator does not provide a 'throw' method"); 3541 } 3542 3543 return ContinueSentinel; 3544 } 3545 3546 var record = tryCatch(method, delegate.iterator, context.arg); 3547 3548 if (record.type === "throw") { 3549 context.method = "throw"; 3550 context.arg = record.arg; 3551 context.delegate = null; 3552 return ContinueSentinel; 3553 } 3554 3555 var info = record.arg; 3556 3557 if (!info) { 3558 context.method = "throw"; 3559 context.arg = new TypeError("iterator result is not an object"); 3560 context.delegate = null; 3561 return ContinueSentinel; 3562 } 3563 3564 if (info.done) { 3565 // Assign the result of the finished delegate to the temporary 3566 // variable specified by delegate.resultName (see delegateYield). 3567 context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield). 3568 3569 context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the 3570 // exception, let the outer generator proceed normally. If 3571 // context.method was "next", forget context.arg since it has been 3572 // "consumed" by the delegate iterator. If context.method was 3573 // "return", allow the original .return call to continue in the 3574 // outer generator. 3575 3576 if (context.method !== "return") { 3577 context.method = "next"; 3578 context.arg = undefined; 3579 } 3580 } else { 3581 // Re-yield the result returned by the delegate method. 3582 return info; 3583 } // The delegate iterator is finished, so forget it and continue with 3584 // the outer generator. 3585 3586 3587 context.delegate = null; 3588 return ContinueSentinel; 3589 } // Define Generator.prototype.{next,throw,return} in terms of the 3590 // unified ._invoke helper method. 3591 3592 3593 defineIteratorMethods(Gp); 3594 Gp[toStringTagSymbol] = "Generator"; // A Generator should always return itself as the iterator object when the 3595 // @@iterator function is called on it. Some browsers' implementations of the 3596 // iterator prototype chain incorrectly implement this, causing the Generator 3597 // object to not be returned from this call. This ensures that doesn't happen. 3598 // See https://github.com/facebook/regenerator/issues/274 for more details. 3599 3600 Gp[iteratorSymbol] = function () { 3601 return this; 3602 }; 3603 3604 Gp.toString = function () { 3605 return "[object Generator]"; 3606 }; 3607 3608 function pushTryEntry(locs) { 3609 var entry = { 3610 tryLoc: locs[0] 3611 }; 3612 3613 if (1 in locs) { 3614 entry.catchLoc = locs[1]; 3615 } 3616 3617 if (2 in locs) { 3618 entry.finallyLoc = locs[2]; 3619 entry.afterLoc = locs[3]; 3620 } 3621 3622 this.tryEntries.push(entry); 3623 } 3624 3625 function resetTryEntry(entry) { 3626 var record = entry.completion || {}; 3627 record.type = "normal"; 3628 delete record.arg; 3629 entry.completion = record; 3630 } 3631 3632 function Context(tryLocsList) { 3633 // The root entry object (effectively a try statement without a catch 3634 // or a finally block) gives us a place to store values thrown from 3635 // locations where there is no enclosing try statement. 3636 this.tryEntries = [{ 3637 tryLoc: "root" 3638 }]; 3639 tryLocsList.forEach(pushTryEntry, this); 3640 this.reset(true); 3641 } 3642 3643 exports.keys = function (object) { 3644 var keys = []; 3645 3646 for (var key in object) { 3647 keys.push(key); 3648 } 3649 3650 keys.reverse(); // Rather than returning an object with a next method, we keep 3651 // things simple and return the next function itself. 3652 3653 return function next() { 3654 while (keys.length) { 3655 var key = keys.pop(); 3656 3657 if (key in object) { 3658 next.value = key; 3659 next.done = false; 3660 return next; 3661 } 3662 } // To avoid creating an additional object, we just hang the .value 3663 // and .done properties off the next function object itself. This 3664 // also ensures that the minifier will not anonymize the function. 3665 3666 3667 next.done = true; 3668 return next; 3669 }; 3670 }; 3671 3672 function values(iterable) { 3673 if (iterable) { 3674 var iteratorMethod = iterable[iteratorSymbol]; 3675 3676 if (iteratorMethod) { 3677 return iteratorMethod.call(iterable); 3678 } 3679 3680 if (typeof iterable.next === "function") { 3681 return iterable; 3682 } 3683 3684 if (!isNaN(iterable.length)) { 3685 var i = -1, 3686 next = function next() { 3687 while (++i < iterable.length) { 3688 if (hasOwn.call(iterable, i)) { 3689 next.value = iterable[i]; 3690 next.done = false; 3691 return next; 3692 } 3693 } 3694 3695 next.value = undefined; 3696 next.done = true; 3697 return next; 3698 }; 3699 3700 return next.next = next; 3701 } 3702 } // Return an iterator with no values. 3703 3704 3705 return { 3706 next: doneResult 3707 }; 3708 } 3709 3710 exports.values = values; 3711 3712 function doneResult() { 3713 return { 3714 value: undefined, 3715 done: true 3716 }; 3717 } 3718 3719 Context.prototype = { 3720 constructor: Context, 3721 reset: function reset(skipTempReset) { 3722 this.prev = 0; 3723 this.next = 0; // Resetting context._sent for legacy support of Babel's 3724 // function.sent implementation. 3725 3726 this.sent = this._sent = undefined; 3727 this.done = false; 3728 this.delegate = null; 3729 this.method = "next"; 3730 this.arg = undefined; 3731 this.tryEntries.forEach(resetTryEntry); 3732 3733 if (!skipTempReset) { 3734 for (var name in this) { 3735 // Not sure about the optimal order of these conditions: 3736 if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) { 3737 this[name] = undefined; 3738 } 3739 } 3740 } 3741 }, 3742 stop: function stop() { 3743 this.done = true; 3744 var rootEntry = this.tryEntries[0]; 3745 var rootRecord = rootEntry.completion; 3746 3747 if (rootRecord.type === "throw") { 3748 throw rootRecord.arg; 3749 } 3750 3751 return this.rval; 3752 }, 3753 dispatchException: function dispatchException(exception) { 3754 if (this.done) { 3755 throw exception; 3756 } 3757 3758 var context = this; 3759 3760 function handle(loc, caught) { 3761 record.type = "throw"; 3762 record.arg = exception; 3763 context.next = loc; 3764 3765 if (caught) { 3766 // If the dispatched exception was caught by a catch block, 3767 // then let that catch block handle the exception normally. 3768 context.method = "next"; 3769 context.arg = undefined; 3770 } 3771 3772 return !!caught; 3773 } 3774 3775 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 3776 var entry = this.tryEntries[i]; 3777 var record = entry.completion; 3778 3779 if (entry.tryLoc === "root") { 3780 // Exception thrown outside of any try block that could handle 3781 // it, so set the completion value of the entire function to 3782 // throw the exception. 3783 return handle("end"); 3784 } 3785 3786 if (entry.tryLoc <= this.prev) { 3787 var hasCatch = hasOwn.call(entry, "catchLoc"); 3788 var hasFinally = hasOwn.call(entry, "finallyLoc"); 3789 3790 if (hasCatch && hasFinally) { 3791 if (this.prev < entry.catchLoc) { 3792 return handle(entry.catchLoc, true); 3793 } else if (this.prev < entry.finallyLoc) { 3794 return handle(entry.finallyLoc); 3795 } 3796 } else if (hasCatch) { 3797 if (this.prev < entry.catchLoc) { 3798 return handle(entry.catchLoc, true); 3799 } 3800 } else if (hasFinally) { 3801 if (this.prev < entry.finallyLoc) { 3802 return handle(entry.finallyLoc); 3803 } 3804 } else { 3805 throw new Error("try statement without catch or finally"); 3806 } 3807 } 3808 } 3809 }, 3810 abrupt: function abrupt(type, arg) { 3811 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 3812 var entry = this.tryEntries[i]; 3813 3814 if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { 3815 var finallyEntry = entry; 3816 break; 3817 } 3818 } 3819 3820 if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) { 3821 // Ignore the finally entry if control is not jumping to a 3822 // location outside the try/catch block. 3823 finallyEntry = null; 3824 } 3825 3826 var record = finallyEntry ? finallyEntry.completion : {}; 3827 record.type = type; 3828 record.arg = arg; 3829 3830 if (finallyEntry) { 3831 this.method = "next"; 3832 this.next = finallyEntry.finallyLoc; 3833 return ContinueSentinel; 3834 } 3835 3836 return this.complete(record); 3837 }, 3838 complete: function complete(record, afterLoc) { 3839 if (record.type === "throw") { 3840 throw record.arg; 3841 } 3842 3843 if (record.type === "break" || record.type === "continue") { 3844 this.next = record.arg; 3845 } else if (record.type === "return") { 3846 this.rval = this.arg = record.arg; 3847 this.method = "return"; 3848 this.next = "end"; 3849 } else if (record.type === "normal" && afterLoc) { 3850 this.next = afterLoc; 3851 } 3852 3853 return ContinueSentinel; 3854 }, 3855 finish: function finish(finallyLoc) { 3856 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 3857 var entry = this.tryEntries[i]; 3858 3859 if (entry.finallyLoc === finallyLoc) { 3860 this.complete(entry.completion, entry.afterLoc); 3861 resetTryEntry(entry); 3862 return ContinueSentinel; 3863 } 3864 } 3865 }, 3866 "catch": function _catch(tryLoc) { 3867 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 3868 var entry = this.tryEntries[i]; 3869 3870 if (entry.tryLoc === tryLoc) { 3871 var record = entry.completion; 3872 3873 if (record.type === "throw") { 3874 var thrown = record.arg; 3875 resetTryEntry(entry); 3876 } 3877 3878 return thrown; 3879 } 3880 } // The context.catch method must only be called with a location 3881 // argument that corresponds to a known catch block. 3882 3883 3884 throw new Error("illegal catch attempt"); 3885 }, 3886 delegateYield: function delegateYield(iterable, resultName, nextLoc) { 3887 this.delegate = { 3888 iterator: values(iterable), 3889 resultName: resultName, 3890 nextLoc: nextLoc 3891 }; 3892 3893 if (this.method === "next") { 3894 // Deliberately forget the last sent value so that we don't 3895 // accidentally pass it on to the delegate. 3896 this.arg = undefined; 3897 } 3898 3899 return ContinueSentinel; 3900 } 3901 }; // Regardless of whether this script is executing as a CommonJS module 3902 // or not, return the runtime object so that we can declare the variable 3903 // regeneratorRuntime in the outer scope, which allows this module to be 3904 // injected easily by `bin/regenerator --include-runtime script.js`. 3905 3906 return exports; 3907}( // If this script is executing as a CommonJS module, use module.exports 3908// as the regeneratorRuntime namespace. Otherwise create a new empty 3909// object. Either way, the resulting object will be used to initialize 3910// the regeneratorRuntime variable at the top of this file. 3911( false ? undefined : _typeof(module)) === "object" ? module.exports : {}); 3912 3913try { 3914 regeneratorRuntime = runtime; 3915} catch (accidentalStrictMode) { 3916 // This module should not be running in strict mode, so the above 3917 // assignment should always work unless something is misconfigured. Just 3918 // in case runtime.js accidentally runs in strict mode, we can escape 3919 // strict mode using a global Function call. This could conceivably fail 3920 // if a Content Security Policy forbids using Function, but in that case 3921 // the proper solution is to fix the accidental strict mode problem. If 3922 // you've misconfigured your bundler to force strict mode and applied a 3923 // CSP to forbid Function, and you're not willing to fix either of those 3924 // problems, please detail your unique predicament in a GitHub issue. 3925 Function("r", "regeneratorRuntime = r")(runtime); 3926} 3927/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module))) 3928 3929/***/ }), 3930
vendor: 1,157 bytes, lines 3931-3960
3931/***/ "./node_modules/webpack/buildin/global.js": 3932/*!***********************************!*\ 3933 !*** (webpack)/buildin/global.js ***! 3934 \***********************************/ 3935/*! no static exports found */ 3936/***/ (function(module, exports) { 3937 3938function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } 3939 3940var g; // This works in non-strict mode 3941 3942g = function () { 3943 return this; 3944}(); 3945 3946try { 3947 // This works if eval is allowed (see CSP) 3948 g = g || new Function("return this")(); 3949} catch (e) { 3950 // This works if the window reference is available 3951 if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === "object") g = window; 3952} // g can still be undefined, but nothing to do about it... 3953// We return undefined, instead of nothing here, so it's 3954// easier to handle this case. if(!global) { ...} 3955 3956 3957module.exports = g; 3958 3959/***/ }), 3960
vendor: 801 bytes, lines 3961-3993
3961/***/ "./node_modules/webpack/buildin/module.js": 3962/*!***********************************!*\ 3963 !*** (webpack)/buildin/module.js ***! 3964 \***********************************/ 3965/*! no static exports found */ 3966/***/ (function(module, exports) { 3967 3968module.exports = function (module) { 3969 if (!module.webpackPolyfill) { 3970 module.deprecate = function () {}; 3971 3972 module.paths = []; // module.parent = undefined by default 3973 3974 if (!module.children) module.children = []; 3975 Object.defineProperty(module, "loaded", { 3976 enumerable: true, 3977 get: function get() { 3978 return module.l; 3979 } 3980 }); 3981 Object.defineProperty(module, "id", { 3982 enumerable: true, 3983 get: function get() { 3984 return module.i; 3985 } 3986 }); 3987 module.webpackPolyfill = 1; 3988 } 3989 3990 return module; 3991}; 3992 3993/***/ })
3993, 3994 3995/***/ 0: 3996/*!*****************************************************!*\ 3997 !*** multi es6-promise-promise ./js/scripts_es6.js ***! 3998 \*****************************************************/ 3999/*! no static exports found */ 4000/***/ (function(module, exports, __webpack_require__) { 4001 4002__webpack_require__(/*! es6-promise-promise */"./node_modules/es6-promise-promise/index.js"); 4003module.exports = __webpack_require__(/*! ./js/scripts_es6.js */"./js/scripts_es6.js"); 4004 4005 4006/***/ }), 4007 4008/***/ 1: 4009/*!***********************!*\ 4010 !*** vertx (ignored) ***! 4011 \***********************/ 4012/*! no static exports found */ 4013/***/ (function(module, exports) { 4014 4015/* (ignored) */ 4016 4017/***/ }) 4018 4019/******/ }); 4020//# sourceMappingURL=scripts.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.