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