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