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, { 40/******/ configurable: false, 41/******/ enumerable: true, 42/******/ get: getter 43/******/ }); 44/******/ } 45/******/ }; 46/******/ 47/******/ // getDefaultExport function for compatibility with non-harmony modules 48/******/ __webpack_require__.n = function(module) { 49/******/ var getter = module && module.__esModule ? 50/******/ function getDefault() { return module['default']; } : 51/******/ function getModuleExports() { return module; }; 52/******/ __webpack_require__.d(getter, 'a', getter); 53/******/ return getter; 54/******/ }; 55/******/ 56/******/ // Object.prototype.hasOwnProperty.call 57/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 58/******/ 59/******/ // __webpack_public_path__ 60/******/ __webpack_require__.p = ""; 61/******/ 62/******/ // Load entry module and return exports 63/******/ return __webpack_require__(__webpack_require__.s = 119); 64/******/ }) 65/************************************************************************/ 66/******/ ({ 67 68/***/ 1: 69/***/ (function(module, exports, __webpack_require__) { 70 71"use strict"; 72 73 74var bind = __webpack_require__(6); 75var isBuffer = __webpack_require__(19); 76 77/*global toString:true*/ 78 79// utils is a library of generic helper functions non-specific to axios 80 81var toString = Object.prototype.toString; 82 83/** 84 * Determine if a value is an Array 85 * 86 * @param {Object} val The value to test 87 * @returns {boolean} True if value is an Array, otherwise false 88 */ 89function isArray(val) { 90 return toString.call(val) === '[object Array]'; 91} 92 93/** 94 * Determine if a value is an ArrayBuffer 95 * 96 * @param {Object} val The value to test 97 * @returns {boolean} True if value is an ArrayBuffer, otherwise false 98 */ 99function isArrayBuffer(val) { 100 return toString.call(val) === '[object ArrayBuffer]'; 101} 102 103/** 104 * Determine if a value is a FormData 105 * 106 * @param {Object} val The value to test 107 * @returns {boolean} True if value is an FormData, otherwise false 108 */ 109function isFormData(val) { 110 return (typeof FormData !== 'undefined') && (val instanceof FormData); 111} 112 113/** 114 * Determine if a value is a view on an ArrayBuffer 115 * 116 * @param {Object} val The value to test 117 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false 118 */ 119function isArrayBufferView(val) { 120 var result; 121 if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { 122 result = ArrayBuffer.isView(val); 123 } else { 124 result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer); 125 } 126 return result; 127} 128 129/** 130 * Determine if a value is a String 131 * 132 * @param {Object} val The value to test 133 * @returns {boolean} True if value is a String, otherwise false 134 */ 135function isString(val) { 136 return typeof val === 'string'; 137} 138 139/** 140 * Determine if a value is a Number 141 * 142 * @param {Object} val The value to test 143 * @returns {boolean} True if value is a Number, otherwise false 144 */ 145function isNumber(val) { 146 return typeof val === 'number'; 147} 148 149/** 150 * Determine if a value is undefined 151 * 152 * @param {Object} val The value to test 153 * @returns {boolean} True if the value is undefined, otherwise false 154 */ 155function isUndefined(val) { 156 return typeof val === 'undefined'; 157} 158 159/** 160 * Determine if a value is an Object 161 * 162 * @param {Object} val The value to test 163 * @returns {boolean} True if value is an Object, otherwise false 164 */ 165function isObject(val) { 166 return val !== null && typeof val === 'object'; 167} 168 169/** 170 * Determine if a value is a Date 171 * 172 * @param {Object} val The value to test 173 * @returns {boolean} True if value is a Date, otherwise false 174 */ 175function isDate(val) { 176 return toString.call(val) === '[object Date]'; 177} 178 179/** 180 * Determine if a value is a File 181 * 182 * @param {Object} val The value to test 183 * @returns {boolean} True if value is a File, otherwise false 184 */ 185function isFile(val) { 186 return toString.call(val) === '[object File]'; 187} 188 189/** 190 * Determine if a value is a Blob 191 * 192 * @param {Object} val The value to test 193 * @returns {boolean} True if value is a Blob, otherwise false 194 */ 195function isBlob(val) { 196 return toString.call(val) === '[object Blob]'; 197} 198 199/** 200 * Determine if a value is a Function 201 * 202 * @param {Object} val The value to test 203 * @returns {boolean} True if value is a Function, otherwise false 204 */ 205function isFunction(val) { 206 return toString.call(val) === '[object Function]'; 207} 208
209/** 210 * Determine if a value is a Stream 211 * 212 * @param {Object} val The value to test 213 * @returns {boolean} True if value is a Stream, otherwise false 214 */ 215function isStream(val) { 216 return isObject(val) && isFunction(val.pipe); 217} 218 219/** 220 * Determine if a value is a URLSearchParams object 221 * 222 * @param {Object} val The value to test 223 * @returns {boolean} True if value is a URLSearchParams object, otherwise false 224 */ 225function isURLSearchParams(val) { 226 return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams; 227} 228 229/** 230 * Trim excess whitespace off the beginning and end of a string 231 * 232 * @param {String} str The String to trim 233 * @returns {String} The String freed of excess whitespace 234 */ 235function trim(str) { 236 return str.replace(/^\s*/, '').replace(/\s*$/, ''); 237} 238 239/** 240 * Determine if we're running in a standard browser environment 241 * 242 * This allows axios to run in a web worker, and react-native. 243 * Both environments support XMLHttpRequest, but not fully standard globals. 244 * 245 * web workers: 246 * typeof window -> undefined 247 * typeof document -> undefined 248 * 249 * react-native: 250 * navigator.product -> 'ReactNative' 251 */ 252function isStandardBrowserEnv() { 253 if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') { 254 return false; 255 } 256 return ( 257 typeof window !== 'undefined' && 258 typeof document !== 'undefined' 259 ); 260} 261 262/** 263 * Iterate over an Array or an Object invoking a function for each item. 264 * 265 * If `obj` is an Array callback will be called passing 266 * the value, index, and complete array for each item. 267 * 268 * If 'obj' is an Object callback will be called passing 269 * the value, key, and complete object for each property. 270 * 271 * @param {Object|Array} obj The object to iterate 272 * @param {Function} fn The callback to invoke for each item 273 */ 274function forEach(obj, fn) { 275 // Don't bother if no value provided 276 if (obj === null || typeof obj === 'undefined') { 277 return; 278 } 279 280 // Force an array if not already something iterable 281 if (typeof obj !== 'object') { 282 /*eslint no-param-reassign:0*/ 283 obj = [obj]; 284 } 285 286 if (isArray(obj)) { 287 // Iterate over array values 288 for (var i = 0, l = obj.length; i < l; i++) { 289 fn.call(null, obj[i], i, obj); 290 } 291 } else { 292 // Iterate over object keys 293 for (var key in obj) { 294 if (Object.prototype.hasOwnProperty.call(obj, key)) { 295 fn.call(null, obj[key], key, obj); 296 } 297 } 298 } 299} 300 301/** 302 * Accepts varargs expecting each argument to be an object, then 303 * immutably merges the properties of each object and returns result. 304 * 305 * When multiple objects contain the same key the later object in 306 * the arguments list will take precedence. 307 * 308 * Example: 309 * 310 * ```js 311 * var result = merge({foo: 123}, {foo: 456}); 312 * console.log(result.foo); // outputs 456 313 * ``` 314 * 315 * @param {Object} obj1 Object to merge 316 * @returns {Object} Result of all merge properties 317 */ 318function merge(/* obj1, obj2, obj3, ... */) { 319 var result = {}; 320 function assignValue(val, key) { 321 if (typeof result[key] === 'object' && typeof val === 'object') { 322 result[key] = merge(result[key], val); 323 } else { 324 result[key] = val; 325 } 326 } 327 328 for (var i = 0, l = arguments.length; i < l; i++) { 329 forEach(arguments[i], assignValue); 330 } 331 return result; 332} 333 334/** 335 * Extends object a by mutably adding to it the properties of object b. 336 * 337 * @param {Object} a The object to be extended 338 * @param {Object} b The object to copy properties from 339 * @param {Object} thisArg The object to bind function to 340 * @return {Object} The resulting value of object a 341 */ 342function extend(a, b, thisArg) { 343 forEach(b, function assignValue(val, key) { 344 if (thisArg && typeof val === 'function') { 345 a[key] = bind(val, thisArg); 346 } else { 347 a[key] = val; 348 } 349 }); 350 return a; 351} 352 353module.exports = { 354 isArray: isArray, 355 isArrayBuffer: isArrayBuffer, 356 isBuffer: isBuffer, 357 isFormData: isFormData, 358 isArrayBufferView: isArrayBufferView, 359 isString: isString, 360 isNumber: isNumber, 361 isObject: isObject, 362 isUndefined: isUndefined, 363 isDate: isDate, 364 isFile: isFile, 365 isBlob: isBlob, 366 isFunction: isFunction, 367 isStream: isStream, 368 isURLSearchParams: isURLSearchParams, 369 isStandardBrowserEnv: isStandardBrowserEnv, 370 forEach: forEach, 371 merge: merge, 372 extend: extend, 373 trim: trim 374}; 375 376 377/***/ }), 378 379/***/ 10: 380/***/ (function(module, exports, __webpack_require__) { 381 382"use strict"; 383 384 385/** 386 * A `Cancel` is an object that is thrown when an operation is canceled. 387 * 388 * @class 389 * @param {string=} message The message. 390 */ 391function Cancel(message) { 392 this.message = message; 393} 394 395Cancel.prototype.toString = function toString() { 396 return 'Cancel' + (this.message ? ': ' + this.message : ''); 397}; 398
399Cancel.prototype.__CANCEL__ = true; 400 401module.exports = Cancel; 402 403 404/***/ }), 405 406/***/ 119: 407/***/ (function(module, exports, __webpack_require__) { 408 409__webpack_require__(120); 410module.exports = __webpack_require__(122); 411 412 413/***/ }), 414 415/***/ 120: 416/***/ (function(module, exports, __webpack_require__) { 417 418"use strict"; 419 420 421var _axios = __webpack_require__(13); 422 423var _axios2 = _interopRequireDefault(_axios); 424 425var _ListenToCopy = __webpack_require__(121); 426 427function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 428 429var _wp$element = wp.element, 430 Component = _wp$element.Component, 431 render = _wp$element.render; 432 433 434document.addEventListener('DOMContentLoaded', function (event) { 435 var searchElement = document.getElementById("WooCopyright-block"); 436 if (searchElement != null) { 437 438 var settings = JSON.parse(searchElement.getAttribute('data-settings')); 439 var items = JSON.parse(searchElement.getAttribute('data-items')); 440 441 render(React.createElement(_ListenToCopy.WCYListen, { settings: settings, items: items }), searchElement); 442 } 443}); 444 445/***/ }), 446 447/***/ 121: 448/***/ (function(module, exports, __webpack_require__) { 449 450"use strict"; 451 452 453Object.defineProperty(exports, "__esModule", { 454 value: true 455}); 456 457var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 458 459var _wp$element = wp.element, 460 Component = _wp$element.Component, 461 render = _wp$element.render, 462 findDOMNode = _wp$element.findDOMNode, 463 Fragment = _wp$element.Fragment, 464 useState = _wp$element.useState, 465 useEffect = _wp$element.useEffect; 466 467 468var alias = 'WooCopyright-'; 469 470var WCYListen = exports.WCYListen = function WCYListen(_ref) { 471 var settings = _ref.settings, 472 items = _ref.items; 473 474 var _useState = useState(""), 475 _useState2 = _slicedToArray(_useState, 2), 476 selectedText = _useState2[0], 477 setSelectedText = _useState2[1]; 478 479 var _useState3 = useState(""), 480 _useState4 = _slicedToArray(_useState3, 2), 481 extraText = _useState4[0], 482 setExtraText = _useState4[1]; 483 484 useEffect(function () { 485 listenToSelection(); 486 listenToCopy(); 487 createExtraText(); 488 }, [selectedText]); 489 490 var getSelectionText = function getSelectionText() { 491 var selectedText = ""; 492 if (window.getSelection) { 493 // all modern browsers and IE9+ 494 selectedText = window.getSelection().toString(); 495 } 496 return selectedText; 497 }; 498 499 var listenToSelection = function listenToSelection() { 500 document.addEventListener('mouseup', function () { 501 var thetext = getSelectionText(); 502 if (thetext.length > 0) { 503 setSelectedText(thetext); 504 } 505 }, false); 506 }; 507 508 var createExtraText = function createExtraText() { 509 var extraText = ""; 510 extraText += settings.read_more; 511 extraText += ": "; 512 extraText += WCY.current_page_url + "?WProtectTrack"; 513 extraText += "\n\n"; 514 515 items.map(function (item, index) { 516 var aditional = item.label + ": " + item.url; 517 if (index != items.length - 1) aditional += " " + settings.delimiter + " "; 518 extraText += aditional; 519 }); 520 521 if (settings.aditional_text != "") { 522 extraText += "\n\n"; 523 extraText += settings.aditional_text; 524 } 525 526 setExtraText(extraText); 527 }; 528 529 var listenToCopy = function listenToCopy() { 530 document.addEventListener('copy', function (e) { 531 e.clipboardData.setData('text/plain', selectedText + "\n\n" + extraText); 532 e.preventDefault(); 533 }); 534 }; 535 536 return null; 537}; 538 539/***/ }), 540 541/***/ 122:
vendor: 5,340 bytes, lines 542-726
542/***/ (function(module, exports) { 543 544// removed by extract-text-webpack-plugin 545 546/***/ }), 547 548/***/ 13: 549/***/ (function(module, exports, __webpack_require__) { 550 551module.exports = __webpack_require__(18); 552 553/***/ }), 554 555/***/ 18: 556/***/ (function(module, exports, __webpack_require__) { 557 558"use strict"; 559 560 561var utils = __webpack_require__(1); 562var bind = __webpack_require__(6); 563var Axios = __webpack_require__(20); 564var defaults = __webpack_require__(3); 565 566/** 567 * Create an instance of Axios 568 * 569 * @param {Object} defaultConfig The default config for the instance 570 * @return {Axios} A new instance of Axios 571 */ 572function createInstance(defaultConfig) { 573 var context = new Axios(defaultConfig); 574 var instance = bind(Axios.prototype.request, context); 575 576 // Copy axios.prototype to instance 577 utils.extend(instance, Axios.prototype, context); 578 579 // Copy context to instance 580 utils.extend(instance, context); 581 582 return instance; 583} 584 585// Create the default instance to be exported 586var axios = createInstance(defaults); 587 588// Expose Axios class to allow class inheritance 589axios.Axios = Axios; 590 591// Factory for creating new instances 592axios.create = function create(instanceConfig) { 593 return createInstance(utils.merge(defaults, instanceConfig)); 594}; 595 596// Expose Cancel & CancelToken 597axios.Cancel = __webpack_require__(10); 598axios.CancelToken = __webpack_require__(33); 599axios.isCancel = __webpack_require__(9); 600 601// Expose all/spread 602axios.all = function all(promises) { 603 return Promise.all(promises); 604}; 605axios.spread = __webpack_require__(34); 606 607module.exports = axios; 608 609// Allow use of default import syntax in TypeScript 610module.exports.default = axios; 611 612 613/***/ }), 614 615/***/ 19: 616/***/ (function(module, exports) { 617 618/*! 619 * Determine if an object is a Buffer 620 * 621 * @author Feross Aboukhadijeh <https://feross.org> 622 * @license MIT 623 */ 624 625module.exports = function isBuffer (obj) { 626 return obj != null && obj.constructor != null && 627 typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) 628} 629 630 631/***/ }), 632 633/***/ 2: 634/***/ (function(module, exports) { 635 636// shim for using process in browser 637var process = module.exports = {}; 638 639// cached from whatever global is present so that test runners that stub it 640// don't break things. But we need to wrap it in a try catch in case it is 641// wrapped in strict mode code which doesn't define any globals. It's inside a 642// function because try/catches deoptimize in certain engines. 643 644var cachedSetTimeout; 645var cachedClearTimeout; 646 647function defaultSetTimout() { 648 throw new Error('setTimeout has not been defined'); 649} 650function defaultClearTimeout () { 651 throw new Error('clearTimeout has not been defined'); 652} 653(function () { 654 try { 655 if (typeof setTimeout === 'function') { 656 cachedSetTimeout = setTimeout; 657 } else { 658 cachedSetTimeout = defaultSetTimout; 659 } 660 } catch (e) { 661 cachedSetTimeout = defaultSetTimout; 662 } 663 try { 664 if (typeof clearTimeout === 'function') { 665 cachedClearTimeout = clearTimeout; 666 } else { 667 cachedClearTimeout = defaultClearTimeout; 668 } 669 } catch (e) { 670 cachedClearTimeout = defaultClearTimeout; 671 } 672} ()) 673function runTimeout(fun) { 674 if (cachedSetTimeout === setTimeout) { 675 //normal enviroments in sane situations 676 return setTimeout(fun, 0); 677 } 678 // if setTimeout wasn't available but was latter defined 679 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 680 cachedSetTimeout = setTimeout; 681 return setTimeout(fun, 0); 682 } 683 try { 684 // when when somebody has screwed with setTimeout but no I.E. maddness 685 return cachedSetTimeout(fun, 0); 686 } catch(e){ 687 try { 688 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 689 return cachedSetTimeout.call(null, fun, 0); 690 } catch(e){ 691 // 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 692 return cachedSetTimeout.call(this, fun, 0); 693 } 694 } 695 696 697} 698function runClearTimeout(marker) { 699 if (cachedClearTimeout === clearTimeout) { 700 //normal enviroments in sane situations 701 return clearTimeout(marker); 702 } 703 // if clearTimeout wasn't available but was latter defined 704 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 705 cachedClearTimeout = clearTimeout; 706 return clearTimeout(marker); 707 } 708 try { 709 // when when somebody has screwed with setTimeout but no I.E. maddness 710 return cachedClearTimeout(marker); 711 } catch (e){ 712 try { 713 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 714 return cachedClearTimeout.call(null, marker); 715 } catch (e){ 716 // 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. 717 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 718 return cachedClearTimeout.call(this, marker); 719 } 720 } 721 722 723 724} 725var queue = []; 726var draining = false;
vendor: 4,584 bytes, lines 727-919
727var currentQueue; 728var queueIndex = -1; 729 730function cleanUpNextTick() { 731 if (!draining || !currentQueue) { 732 return; 733 } 734 draining = false; 735 if (currentQueue.length) { 736 queue = currentQueue.concat(queue); 737 } else { 738 queueIndex = -1; 739 } 740 if (queue.length) { 741 drainQueue(); 742 } 743} 744 745function drainQueue() { 746 if (draining) { 747 return; 748 } 749 var timeout = runTimeout(cleanUpNextTick); 750 draining = true; 751 752 var len = queue.length; 753 while(len) { 754 currentQueue = queue; 755 queue = []; 756 while (++queueIndex < len) { 757 if (currentQueue) { 758 currentQueue[queueIndex].run(); 759 } 760 } 761 queueIndex = -1; 762 len = queue.length; 763 } 764 currentQueue = null; 765 draining = false; 766 runClearTimeout(timeout); 767} 768 769process.nextTick = function (fun) { 770 var args = new Array(arguments.length - 1); 771 if (arguments.length > 1) { 772 for (var i = 1; i < arguments.length; i++) { 773 args[i - 1] = arguments[i]; 774 } 775 } 776 queue.push(new Item(fun, args)); 777 if (queue.length === 1 && !draining) { 778 runTimeout(drainQueue); 779 } 780}; 781 782// v8 likes predictible objects 783function Item(fun, array) { 784 this.fun = fun; 785 this.array = array; 786} 787Item.prototype.run = function () { 788 this.fun.apply(null, this.array); 789}; 790process.title = 'browser'; 791process.browser = true; 792process.env = {}; 793process.argv = []; 794process.version = ''; // empty string to avoid regexp issues 795process.versions = {}; 796 797function noop() {} 798 799process.on = noop; 800process.addListener = noop; 801process.once = noop; 802process.off = noop; 803process.removeListener = noop; 804process.removeAllListeners = noop; 805process.emit = noop; 806process.prependListener = noop; 807process.prependOnceListener = noop; 808 809process.listeners = function (name) { return [] } 810 811process.binding = function (name) { 812 throw new Error('process.binding is not supported'); 813}; 814 815process.cwd = function () { return '/' }; 816process.chdir = function (dir) { 817 throw new Error('process.chdir is not supported'); 818}; 819process.umask = function() { return 0; }; 820 821 822/***/ }), 823 824/***/ 20: 825/***/ (function(module, exports, __webpack_require__) { 826 827"use strict"; 828 829 830var defaults = __webpack_require__(3); 831var utils = __webpack_require__(1); 832var InterceptorManager = __webpack_require__(28); 833var dispatchRequest = __webpack_require__(29); 834 835/** 836 * Create a new instance of Axios 837 * 838 * @param {Object} instanceConfig The default config for the instance 839 */ 840function Axios(instanceConfig) { 841 this.defaults = instanceConfig; 842 this.interceptors = { 843 request: new InterceptorManager(), 844 response: new InterceptorManager() 845 }; 846} 847 848/** 849 * Dispatch a request 850 * 851 * @param {Object} config The config specific for this request (merged with this.defaults) 852 */ 853Axios.prototype.request = function request(config) { 854 /*eslint no-param-reassign:0*/ 855 // Allow for axios('example/url'[, config]) a la fetch API 856 if (typeof config === 'string') { 857 config = utils.merge({ 858 url: arguments[0] 859 }, arguments[1]); 860 } 861 862 config = utils.merge(defaults, {method: 'get'}, this.defaults, config); 863 config.method = config.method.toLowerCase(); 864 865 // Hook up interceptors middleware 866 var chain = [dispatchRequest, undefined]; 867 var promise = Promise.resolve(config); 868 869 this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { 870 chain.unshift(interceptor.fulfilled, interceptor.rejected); 871 }); 872 873 this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { 874 chain.push(interceptor.fulfilled, interceptor.rejected); 875 }); 876 877 while (chain.length) { 878 promise = promise.then(chain.shift(), chain.shift()); 879 } 880 881 return promise; 882}; 883 884// Provide aliases for supported request methods 885utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) { 886 /*eslint func-names:0*/ 887 Axios.prototype[method] = function(url, config) { 888 return this.request(utils.merge(config || {}, { 889 method: method, 890 url: url 891 })); 892 }; 893}); 894 895utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 896 /*eslint func-names:0*/ 897 Axios.prototype[method] = function(url, data, config) { 898 return this.request(utils.merge(config || {}, { 899 method: method, 900 url: url, 901 data: data 902 })); 903 }; 904}); 905 906module.exports = Axios; 907 908 909/***/ }), 910 911/***/ 21: 912/***/ (function(module, exports, __webpack_require__) { 913 914"use strict"; 915 916 917var utils = __webpack_require__(1); 918 919module.exports = function normalizeHeaderName(headers, normalizedName) {
920 utils.forEach(headers, function processHeader(value, name) { 921 if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { 922 headers[normalizedName] = value; 923 delete headers[name]; 924 } 925 }); 926}; 927 928 929/***/ }), 930 931/***/ 22: 932/***/ (function(module, exports, __webpack_require__) { 933 934"use strict"; 935 936 937var createError = __webpack_require__(8); 938 939/** 940 * Resolve or reject a Promise based on response status. 941 * 942 * @param {Function} resolve A function that resolves the promise. 943 * @param {Function} reject A function that rejects the promise. 944 * @param {object} response The response. 945 */ 946module.exports = function settle(resolve, reject, response) { 947 var validateStatus = response.config.validateStatus; 948 // Note: status is not exposed by XDomainRequest 949 if (!response.status || !validateStatus || validateStatus(response.status)) { 950 resolve(response); 951 } else { 952 reject(createError( 953 'Request failed with status code ' + response.status, 954 response.config, 955 null, 956 response.request, 957 response 958 )); 959 } 960}; 961 962 963/***/ }), 964 965/***/ 23: 966/***/ (function(module, exports, __webpack_require__) { 967 968"use strict"; 969 970 971/** 972 * Update an Error with the specified config, error code, and response. 973 * 974 * @param {Error} error The error to update. 975 * @param {Object} config The config. 976 * @param {string} [code] The error code (for example, 'ECONNABORTED'). 977 * @param {Object} [request] The request. 978 * @param {Object} [response] The response. 979 * @returns {Error} The error. 980 */ 981module.exports = function enhanceError(error, config, code, request, response) { 982 error.config = config; 983 if (code) { 984 error.code = code; 985 } 986 error.request = request; 987 error.response = response; 988 return error; 989}; 990 991 992/***/ }), 993 994/***/ 24: 995/***/ (function(module, exports, __webpack_require__) { 996 997"use strict"; 998 999 1000var utils = __webpack_require__(1); 1001 1002function encode(val) { 1003 return encodeURIComponent(val). 1004 replace(/%40/gi, '@'). 1005 replace(/%3A/gi, ':'). 1006 replace(/%24/g, '$'). 1007 replace(/%2C/gi, ','). 1008 replace(/%20/g, '+'). 1009 replace(/%5B/gi, '['). 1010 replace(/%5D/gi, ']'); 1011} 1012 1013/** 1014 * Build a URL by appending params to the end 1015 * 1016 * @param {string} url The base of the url (e.g., http://www.google.com) 1017 * @param {object} [params] The params to be appended 1018 * @returns {string} The formatted url 1019 */ 1020module.exports = function buildURL(url, params, paramsSerializer) { 1021 /*eslint no-param-reassign:0*/ 1022 if (!params) { 1023 return url; 1024 } 1025 1026 var serializedParams; 1027 if (paramsSerializer) { 1028 serializedParams = paramsSerializer(params); 1029 } else if (utils.isURLSearchParams(params)) { 1030 serializedParams = params.toString(); 1031 } else { 1032 var parts = []; 1033 1034 utils.forEach(params, function serialize(val, key) { 1035 if (val === null || typeof val === 'undefined') { 1036 return; 1037 } 1038 1039 if (utils.isArray(val)) { 1040 key = key + '[]'; 1041 } else { 1042 val = [val]; 1043 } 1044 1045 utils.forEach(val, function parseValue(v) { 1046 if (utils.isDate(v)) { 1047 v = v.toISOString(); 1048 } else if (utils.isObject(v)) { 1049 v = JSON.stringify(v); 1050 } 1051 parts.push(encode(key) + '=' + encode(v)); 1052 }); 1053 }); 1054 1055 serializedParams = parts.join('&'); 1056 } 1057 1058 if (serializedParams) { 1059 url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; 1060 } 1061 1062 return url; 1063}; 1064 1065 1066/***/ }), 1067 1068/***/ 25: 1069/***/ (function(module, exports, __webpack_require__) { 1070 1071"use strict"; 1072 1073 1074var utils = __webpack_require__(1); 1075 1076// Headers whose duplicates are ignored by node 1077// c.f. https://nodejs.org/api/http.html#http_message_headers 1078var ignoreDuplicateOf = [ 1079 'age', 'authorization', 'content-length', 'content-type', 'etag', 1080 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 1081 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 1082 'referer', 'retry-after', 'user-agent' 1083]; 1084 1085/** 1086 * Parse headers into an object 1087 * 1088 * ``` 1089 * Date: Wed, 27 Aug 2014 08:58:49 GMT 1090 * Content-Type: application/json 1091 * Connection: keep-alive 1092 * Transfer-Encoding: chunked 1093 * ``` 1094 * 1095 * @param {String} headers Headers needing to be parsed 1096 * @returns {Object} Headers parsed into an object 1097 */ 1098module.exports = function parseHeaders(headers) { 1099 var parsed = {}; 1100 var key; 1101 var val; 1102 var i; 1103 1104 if (!headers) { return parsed; } 1105
vendor: 5,476 bytes, lines 1106-1313
1106 utils.forEach(headers.split('\n'), function parser(line) { 1107 i = line.indexOf(':'); 1108 key = utils.trim(line.substr(0, i)).toLowerCase(); 1109 val = utils.trim(line.substr(i + 1)); 1110 1111 if (key) { 1112 if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) { 1113 return; 1114 } 1115 if (key === 'set-cookie') { 1116 parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]); 1117 } else { 1118 parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; 1119 } 1120 } 1121 }); 1122 1123 return parsed; 1124}; 1125 1126 1127/***/ }), 1128 1129/***/ 26: 1130/***/ (function(module, exports, __webpack_require__) { 1131 1132"use strict"; 1133 1134 1135var utils = __webpack_require__(1); 1136 1137module.exports = ( 1138 utils.isStandardBrowserEnv() ? 1139 1140 // Standard browser envs have full support of the APIs needed to test 1141 // whether the request URL is of the same origin as current location. 1142 (function standardBrowserEnv() { 1143 var msie = /(msie|trident)/i.test(navigator.userAgent); 1144 var urlParsingNode = document.createElement('a'); 1145 var originURL; 1146 1147 /** 1148 * Parse a URL to discover it's components 1149 * 1150 * @param {String} url The URL to be parsed 1151 * @returns {Object} 1152 */ 1153 function resolveURL(url) { 1154 var href = url; 1155 1156 if (msie) { 1157 // IE needs attribute set twice to normalize properties 1158 urlParsingNode.setAttribute('href', href); 1159 href = urlParsingNode.href; 1160 } 1161 1162 urlParsingNode.setAttribute('href', href); 1163 1164 // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils 1165 return { 1166 href: urlParsingNode.href, 1167 protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', 1168 host: urlParsingNode.host, 1169 search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', 1170 hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', 1171 hostname: urlParsingNode.hostname, 1172 port: urlParsingNode.port, 1173 pathname: (urlParsingNode.pathname.charAt(0) === '/') ? 1174 urlParsingNode.pathname : 1175 '/' + urlParsingNode.pathname 1176 }; 1177 } 1178 1179 originURL = resolveURL(window.location.href); 1180 1181 /** 1182 * Determine if a URL shares the same origin as the current location 1183 * 1184 * @param {String} requestURL The URL to test 1185 * @returns {boolean} True if URL shares the same origin, otherwise false 1186 */ 1187 return function isURLSameOrigin(requestURL) { 1188 var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL; 1189 return (parsed.protocol === originURL.protocol && 1190 parsed.host === originURL.host); 1191 }; 1192 })() : 1193 1194 // Non standard browser envs (web workers, react-native) lack needed support. 1195 (function nonStandardBrowserEnv() { 1196 return function isURLSameOrigin() { 1197 return true; 1198 }; 1199 })() 1200); 1201 1202 1203/***/ }), 1204 1205/***/ 27: 1206/***/ (function(module, exports, __webpack_require__) { 1207 1208"use strict"; 1209 1210 1211var utils = __webpack_require__(1); 1212 1213module.exports = ( 1214 utils.isStandardBrowserEnv() ? 1215 1216 // Standard browser envs support document.cookie 1217 (function standardBrowserEnv() { 1218 return { 1219 write: function write(name, value, expires, path, domain, secure) { 1220 var cookie = []; 1221 cookie.push(name + '=' + encodeURIComponent(value)); 1222 1223 if (utils.isNumber(expires)) { 1224 cookie.push('expires=' + new Date(expires).toGMTString()); 1225 } 1226 1227 if (utils.isString(path)) { 1228 cookie.push('path=' + path); 1229 } 1230 1231 if (utils.isString(domain)) { 1232 cookie.push('domain=' + domain); 1233 } 1234 1235 if (secure === true) { 1236 cookie.push('secure'); 1237 } 1238 1239 document.cookie = cookie.join('; '); 1240 }, 1241 1242 read: function read(name) { 1243 var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); 1244 return (match ? decodeURIComponent(match[3]) : null); 1245 }, 1246 1247 remove: function remove(name) { 1248 this.write(name, '', Date.now() - 86400000); 1249 } 1250 }; 1251 })() : 1252 1253 // Non standard browser env (web workers, react-native) lack needed support. 1254 (function nonStandardBrowserEnv() { 1255 return { 1256 write: function write() {}, 1257 read: function read() { return null; }, 1258 remove: function remove() {} 1259 }; 1260 })() 1261); 1262 1263 1264/***/ }), 1265 1266/***/ 28: 1267/***/ (function(module, exports, __webpack_require__) { 1268 1269"use strict"; 1270 1271 1272var utils = __webpack_require__(1); 1273 1274function InterceptorManager() { 1275 this.handlers = []; 1276} 1277 1278/** 1279 * Add a new interceptor to the stack 1280 * 1281 * @param {Function} fulfilled The function to handle `then` for a `Promise` 1282 * @param {Function} rejected The function to handle `reject` for a `Promise` 1283 * 1284 * @return {Number} An ID used to remove interceptor later 1285 */ 1286InterceptorManager.prototype.use = function use(fulfilled, rejected) { 1287 this.handlers.push({ 1288 fulfilled: fulfilled, 1289 rejected: rejected 1290 }); 1291 return this.handlers.length - 1; 1292}; 1293 1294/** 1295 * Remove an interceptor from the stack 1296 * 1297 * @param {Number} id The ID that was returned by `use` 1298 */ 1299InterceptorManager.prototype.eject = function eject(id) { 1300 if (this.handlers[id]) { 1301 this.handlers[id] = null; 1302 } 1303}; 1304 1305/** 1306 * Iterate over all the registered interceptors 1307 * 1308 * This method is particularly useful for skipping over any 1309 * interceptors that may have become `null` calling `eject`. 1310 * 1311 * @param {Function} fn The function to call for each interceptor 1312 */ 1313InterceptorManager.prototype.forEach = function forEach(fn) {
1314 utils.forEach(this.handlers, function forEachHandler(h) { 1315 if (h !== null) { 1316 fn(h); 1317 } 1318 }); 1319}; 1320 1321module.exports = InterceptorManager; 1322 1323 1324/***/ }), 1325 1326/***/ 29: 1327/***/ (function(module, exports, __webpack_require__) { 1328 1329"use strict"; 1330 1331 1332var utils = __webpack_require__(1); 1333var transformData = __webpack_require__(30); 1334var isCancel = __webpack_require__(9); 1335var defaults = __webpack_require__(3); 1336var isAbsoluteURL = __webpack_require__(31); 1337var combineURLs = __webpack_require__(32); 1338 1339/** 1340 * Throws a `Cancel` if cancellation has been requested. 1341 */ 1342function throwIfCancellationRequested(config) { 1343 if (config.cancelToken) { 1344 config.cancelToken.throwIfRequested(); 1345 } 1346} 1347 1348/** 1349 * Dispatch a request to the server using the configured adapter. 1350 * 1351 * @param {object} config The config that is to be used for the request 1352 * @returns {Promise} The Promise to be fulfilled 1353 */ 1354module.exports = function dispatchRequest(config) { 1355 throwIfCancellationRequested(config); 1356 1357 // Support baseURL config 1358 if (config.baseURL && !isAbsoluteURL(config.url)) { 1359 config.url = combineURLs(config.baseURL, config.url); 1360 } 1361 1362 // Ensure headers exist 1363 config.headers = config.headers || {}; 1364 1365 // Transform request data 1366 config.data = transformData( 1367 config.data, 1368 config.headers, 1369 config.transformRequest 1370 ); 1371 1372 // Flatten headers 1373 config.headers = utils.merge( 1374 config.headers.common || {}, 1375 config.headers[config.method] || {}, 1376 config.headers || {} 1377 ); 1378 1379 utils.forEach( 1380 ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], 1381 function cleanHeaderConfig(method) { 1382 delete config.headers[method]; 1383 } 1384 ); 1385 1386 var adapter = config.adapter || defaults.adapter; 1387 1388 return adapter(config).then(function onAdapterResolution(response) { 1389 throwIfCancellationRequested(config); 1390 1391 // Transform response data 1392 response.data = transformData( 1393 response.data, 1394 response.headers, 1395 config.transformResponse 1396 ); 1397 1398 return response; 1399 }, function onAdapterRejection(reason) { 1400 if (!isCancel(reason)) { 1401 throwIfCancellationRequested(config); 1402 1403 // Transform response data 1404 if (reason && reason.response) { 1405 reason.response.data = transformData( 1406 reason.response.data, 1407 reason.response.headers, 1408 config.transformResponse 1409 ); 1410 } 1411 } 1412 1413 return Promise.reject(reason); 1414 }); 1415}; 1416 1417 1418/***/ }), 1419 1420/***/ 3: 1421/***/ (function(module, exports, __webpack_require__) { 1422 1423"use strict"; 1424/* WEBPACK VAR INJECTION */(function(process) { 1425 1426var utils = __webpack_require__(1); 1427var normalizeHeaderName = __webpack_require__(21); 1428 1429var DEFAULT_CONTENT_TYPE = { 1430 'Content-Type': 'application/x-www-form-urlencoded' 1431}; 1432 1433function setContentTypeIfUnset(headers, value) { 1434 if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) { 1435 headers['Content-Type'] = value; 1436 } 1437} 1438 1439function getDefaultAdapter() { 1440 var adapter; 1441 if (typeof XMLHttpRequest !== 'undefined') { 1442 // For browsers use XHR adapter 1443 adapter = __webpack_require__(7); 1444 } else if (typeof process !== 'undefined') { 1445 // For node use HTTP adapter 1446 adapter = __webpack_require__(7); 1447 } 1448 return adapter; 1449} 1450 1451var defaults = { 1452 adapter: getDefaultAdapter(), 1453 1454 transformRequest: [function transformRequest(data, headers) { 1455 normalizeHeaderName(headers, 'Content-Type'); 1456 if (utils.isFormData(data) || 1457 utils.isArrayBuffer(data) || 1458 utils.isBuffer(data) || 1459 utils.isStream(data) || 1460 utils.isFile(data) || 1461 utils.isBlob(data) 1462 ) { 1463 return data; 1464 } 1465 if (utils.isArrayBufferView(data)) { 1466 return data.buffer; 1467 } 1468 if (utils.isURLSearchParams(data)) { 1469 setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8'); 1470 return data.toString(); 1471 } 1472 if (utils.isObject(data)) { 1473 setContentTypeIfUnset(headers, 'application/json;charset=utf-8'); 1474 return JSON.stringify(data); 1475 } 1476 return data; 1477 }], 1478 1479 transformResponse: [function transformResponse(data) { 1480 /*eslint no-param-reassign:0*/ 1481 if (typeof data === 'string') {
1482 try { 1483 data = JSON.parse(data); 1484 } catch (e) { /* Ignore */ } 1485 } 1486 return data; 1487 }], 1488 1489 /** 1490 * A timeout in milliseconds to abort a request. If set to 0 (default) a 1491 * timeout is not created. 1492 */ 1493 timeout: 0, 1494 1495 xsrfCookieName: 'XSRF-TOKEN', 1496 xsrfHeaderName: 'X-XSRF-TOKEN', 1497 1498 maxContentLength: -1, 1499 1500 validateStatus: function validateStatus(status) { 1501 return status >= 200 && status < 300; 1502 } 1503}; 1504 1505defaults.headers = { 1506 common: { 1507 'Accept': 'application/json, text/plain, */*' 1508 } 1509}; 1510 1511utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) { 1512 defaults.headers[method] = {}; 1513}); 1514 1515utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 1516 defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); 1517}); 1518 1519module.exports = defaults; 1520 1521/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2))) 1522 1523/***/ }), 1524 1525/***/ 30: 1526/***/ (function(module, exports, __webpack_require__) { 1527 1528"use strict"; 1529 1530 1531var utils = __webpack_require__(1); 1532 1533/** 1534 * Transform the data for a request or a response 1535 * 1536 * @param {Object|String} data The data to be transformed 1537 * @param {Array} headers The headers for the request or response 1538 * @param {Array|Function} fns A single function or Array of functions 1539 * @returns {*} The resulting transformed data 1540 */ 1541module.exports = function transformData(data, headers, fns) { 1542 /*eslint no-param-reassign:0*/ 1543 utils.forEach(fns, function transform(fn) { 1544 data = fn(data, headers); 1545 }); 1546 1547 return data; 1548}; 1549 1550 1551/***/ }), 1552 1553/***/ 31: 1554/***/ (function(module, exports, __webpack_require__) { 1555 1556"use strict"; 1557 1558 1559/** 1560 * Determines whether the specified URL is absolute 1561 * 1562 * @param {string} url The URL to test 1563 * @returns {boolean} True if the specified URL is absolute, otherwise false 1564 */ 1565module.exports = function isAbsoluteURL(url) { 1566 // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL). 1567 // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed 1568 // by any combination of letters, digits, plus, period, or hyphen. 1569 return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url); 1570}; 1571 1572 1573/***/ }), 1574 1575/***/ 32: 1576/***/ (function(module, exports, __webpack_require__) { 1577 1578"use strict"; 1579 1580 1581/** 1582 * Creates a new URL by combining the specified URLs 1583 * 1584 * @param {string} baseURL The base URL 1585 * @param {string} relativeURL The relative URL 1586 * @returns {string} The combined URL 1587 */ 1588module.exports = function combineURLs(baseURL, relativeURL) { 1589 return relativeURL 1590 ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') 1591 : baseURL; 1592}; 1593 1594 1595/***/ }), 1596 1597/***/ 33: 1598/***/ (function(module, exports, __webpack_require__) { 1599 1600"use strict"; 1601 1602 1603var Cancel = __webpack_require__(10); 1604 1605/** 1606 * A `CancelToken` is an object that can be used to request cancellation of an operation. 1607 * 1608 * @class 1609 * @param {Function} executor The executor function. 1610 */ 1611function CancelToken(executor) { 1612 if (typeof executor !== 'function') { 1613 throw new TypeError('executor must be a function.'); 1614 } 1615 1616 var resolvePromise; 1617 this.promise = new Promise(function promiseExecutor(resolve) { 1618 resolvePromise = resolve; 1619 }); 1620 1621 var token = this; 1622 executor(function cancel(message) { 1623 if (token.reason) { 1624 // Cancellation has already been requested 1625 return; 1626 } 1627 1628 token.reason = new Cancel(message); 1629 resolvePromise(token.reason); 1630 }); 1631} 1632 1633/** 1634 * Throws a `Cancel` if cancellation has been requested. 1635 */ 1636CancelToken.prototype.throwIfRequested = function throwIfRequested() { 1637 if (this.reason) { 1638 throw this.reason; 1639 } 1640}; 1641 1642/** 1643 * Returns an object that contains a new `CancelToken` and a function that, when called, 1644 * cancels the `CancelToken`. 1645 */ 1646CancelToken.source = function source() { 1647 var cancel; 1648 var token = new CancelToken(function executor(c) { 1649 cancel = c; 1650 }); 1651 return { 1652 token: token, 1653 cancel: cancel 1654 }; 1655}; 1656 1657module.exports = CancelToken; 1658 1659 1660/***/ }), 1661 1662/***/ 34: 1663/***/ (function(module, exports, __webpack_require__) { 1664 1665"use strict"; 1666 1667 1668/** 1669 * Syntactic sugar for invoking a function and expanding an array for arguments. 1670 * 1671 * Common use case would be to use `Function.prototype.apply`. 1672 * 1673 * ```js 1674 * function f(x, y, z) {} 1675 * var args = [1, 2, 3];
1676 * f.apply(null, args); 1677 * ``` 1678 * 1679 * With `spread` this example can be re-written. 1680 * 1681 * ```js 1682 * spread(function(x, y, z) {})([1, 2, 3]); 1683 * ``` 1684 * 1685 * @param {Function} callback 1686 * @returns {Function} 1687 */ 1688module.exports = function spread(callback) { 1689 return function wrap(arr) { 1690 return callback.apply(null, arr); 1691 }; 1692}; 1693 1694 1695/***/ }), 1696 1697/***/ 6: 1698/***/ (function(module, exports, __webpack_require__) { 1699 1700"use strict"; 1701 1702 1703module.exports = function bind(fn, thisArg) { 1704 return function wrap() { 1705 var args = new Array(arguments.length); 1706 for (var i = 0; i < args.length; i++) { 1707 args[i] = arguments[i]; 1708 } 1709 return fn.apply(thisArg, args); 1710 }; 1711}; 1712 1713 1714/***/ }), 1715 1716/***/ 7: 1717/***/ (function(module, exports, __webpack_require__) { 1718 1719"use strict"; 1720 1721 1722var utils = __webpack_require__(1); 1723var settle = __webpack_require__(22); 1724var buildURL = __webpack_require__(24); 1725var parseHeaders = __webpack_require__(25); 1726var isURLSameOrigin = __webpack_require__(26); 1727var createError = __webpack_require__(8); 1728 1729module.exports = function xhrAdapter(config) { 1730 return new Promise(function dispatchXhrRequest(resolve, reject) { 1731 var requestData = config.data; 1732 var requestHeaders = config.headers; 1733 1734 if (utils.isFormData(requestData)) { 1735 delete requestHeaders['Content-Type']; // Let the browser set it 1736 } 1737 1738 var request = new XMLHttpRequest(); 1739 1740 // HTTP basic authentication 1741 if (config.auth) { 1742 var username = config.auth.username || ''; 1743 var password = config.auth.password || ''; 1744 requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password); 1745 } 1746 1747 request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true); 1748 1749 // Set the request timeout in MS 1750 request.timeout = config.timeout; 1751 1752 // Listen for ready state 1753 request.onreadystatechange = function handleLoad() { 1754 if (!request || request.readyState !== 4) { 1755 return; 1756 } 1757 1758 // The request errored out and we didn't get a response, this will be 1759 // handled by onerror instead 1760 // With one exception: request that using file: protocol, most browsers 1761 // will return status as 0 even though it's a successful request 1762 if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) { 1763 return; 1764 } 1765 1766 // Prepare the response 1767 var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null; 1768 var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response; 1769 var response = { 1770 data: responseData, 1771 status: request.status, 1772 statusText: request.statusText, 1773 headers: responseHeaders, 1774 config: config, 1775 request: request 1776 }; 1777 1778 settle(resolve, reject, response); 1779 1780 // Clean up request 1781 request = null; 1782 }; 1783 1784 // Handle low level network errors 1785 request.onerror = function handleError() { 1786 // Real errors are hidden from us by the browser 1787 // onerror should only fire if it's a network error 1788 reject(createError('Network Error', config, null, request)); 1789 1790 // Clean up request 1791 request = null; 1792 }; 1793 1794 // Handle timeout 1795 request.ontimeout = function handleTimeout() { 1796 reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED', 1797 request)); 1798 1799 // Clean up request 1800 request = null; 1801 }; 1802 1803 // Add xsrf header 1804 // This is only done if running in a standard browser environment. 1805 // Specifically not if we're in a web worker, or react-native. 1806 if (utils.isStandardBrowserEnv()) { 1807 var cookies = __webpack_require__(27); 1808 1809 // Add xsrf header 1810 var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ? 1811 cookies.read(config.xsrfCookieName) : 1812 undefined; 1813 1814 if (xsrfValue) { 1815 requestHeaders[config.xsrfHeaderName] = xsrfValue; 1816 } 1817 } 1818 1819 // Add headers to the request 1820 if ('setRequestHeader' in request) {
1821 utils.forEach(requestHeaders, function setRequestHeader(val, key) { 1822 if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') { 1823 // Remove Content-Type if data is undefined 1824 delete requestHeaders[key]; 1825 } else { 1826 // Otherwise add header to the request 1827 request.setRequestHeader(key, val); 1828 } 1829 }); 1830 } 1831 1832 // Add withCredentials to request if needed 1833 if (config.withCredentials) { 1834 request.withCredentials = true; 1835 } 1836 1837 // Add responseType to request if needed 1838 if (config.responseType) { 1839 try { 1840 request.responseType = config.responseType; 1841 } catch (e) { 1842 // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2. 1843 // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function. 1844 if (config.responseType !== 'json') { 1845 throw e; 1846 } 1847 } 1848 } 1849 1850 // Handle progress if needed 1851 if (typeof config.onDownloadProgress === 'function') { 1852 request.addEventListener('progress', config.onDownloadProgress); 1853 } 1854 1855 // Not all browsers support upload events 1856 if (typeof config.onUploadProgress === 'function' && request.upload) { 1857 request.upload.addEventListener('progress', config.onUploadProgress); 1858 } 1859 1860 if (config.cancelToken) { 1861 // Handle cancellation 1862 config.cancelToken.promise.then(function onCanceled(cancel) { 1863 if (!request) { 1864 return; 1865 } 1866 1867 request.abort(); 1868 reject(cancel); 1869 // Clean up request 1870 request = null; 1871 }); 1872 } 1873 1874 if (requestData === undefined) { 1875 requestData = null; 1876 } 1877 1878 // Send the request 1879 request.send(requestData); 1880 }); 1881}; 1882 1883 1884/***/ }), 1885 1886/***/ 8: 1887/***/ (function(module, exports, __webpack_require__) { 1888 1889"use strict"; 1890 1891 1892var enhanceError = __webpack_require__(23); 1893 1894/** 1895 * Create an Error with the specified message, config, error code, request and response. 1896 * 1897 * @param {string} message The error message. 1898 * @param {Object} config The config. 1899 * @param {string} [code] The error code (for example, 'ECONNABORTED'). 1900 * @param {Object} [request] The request. 1901 * @param {Object} [response] The response. 1902 * @returns {Error} The created error. 1903 */ 1904module.exports = function createError(message, config, code, request, response) { 1905 var error = new Error(message); 1906 return enhanceError(error, config, code, request, response); 1907}; 1908 1909 1910/***/ }), 1911 1912/***/ 9: 1913/***/ (function(module, exports, __webpack_require__) { 1914 1915"use strict"; 1916 1917 1918module.exports = function isCancel(value) { 1919 return !!(value && value.__CANCEL__); 1920}; 1921 1922 1923/***/ }) 1924 1925/******/ }); 1926//# sourceMappingURL=frontend.build.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.