{"version":3,"sources":["webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/stackblur-canvas/dist/stackblur-es.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/rgbcolor/index.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:///../node_modules/regenerator-runtime/runtime.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/regenerator/index.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/get.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/superPropBase.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/slicedToArray.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/inherits.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/process/browser.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/performance-now/src/performance-now.coffee","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/createClass.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/raf/index.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/defineProperty.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:///C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/typeof.js"],"names":["module","exports","arr","i","Symbol","iterator","Object","_arr","_n","_d","_e","undefined","_s","_i","next","done","push","value","length","err","_typeof","obj","constructor","prototype","__webpack_require__","d","__webpack_exports__","processCanvasRGBA","mulTable","shgTable","getImageDataFromCanvas","canvas","topX","topY","width","height","document","getElementById","TypeError","context","getContext","getImageData","e","Error","radius","isNaN","imageData","stackEnd","pixels","data","div","widthMinus1","heightMinus1","radiusPlus1","sumFactor","stackStart","BlurStack","stack","stackIn","stackOut","yw","yi","mulSum","shgSum","y","pr","pg","pb","pa","r","g","b","a","rInSum","gInSum","bInSum","aInSum","rOutSum","gOutSum","bOutSum","aOutSum","rSum","gSum","bSum","aSum","_i2","p","rbs","x","paInitial","_a2","_p","_stackOut","_r","_g","_b","_a","_x","_pr","_pg","_pb","_pa","_rOutSum","_gOutSum","_bOutSum","_aOutSum","_rSum","_gSum","_bSum","_aSum","_i3","yp","_gInSum","_bInSum","_aInSum","_rInSum","_i4","_rbs","_y","_p2","processImageDataRGBA","putImageData","instance","Constructor","_classCallCheck","this","color_string","ok","alpha","charAt","substr","replace","toLowerCase","simple_colors","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dodgerblue","feldspar","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgrey","lightgreen","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslateblue","lightslategray","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","violetred","wheat","white","whitesmoke","yellow","yellowgreen","color_defs","re","example","process","bits","parseInt","parseFloat","processor","exec","channels","toRGB","toRGBA","toHex","toString","getHelpXML","examples","Array","j","sc","xml","createElement","setAttribute","list_item","list_color","RGBColor","example_div","style","cssText","appendChild","createTextNode","list_item_value","len","arr2","runtime","Op","hasOwn","hasOwnProperty","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","Context","_invoke","state","GenStateSuspendedStart","method","arg","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","type","GenStateSuspendedYield","makeInvokeMethod","fn","call","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","resolve","reject","invoke","result","__await","then","unwrapped","error","info","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","displayName","isGeneratorFunction","genFun","ctor","name","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","keys","object","key","reverse","pop","skipTempReset","prev","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","catch","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","ReferenceError","superPropBase","_get","target","property","receiver","Reflect","get","base","desc","getOwnPropertyDescriptor","asyncGeneratorStep","gen","_next","_throw","args","arguments","apply","isArray","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","subClass","superClass","writable","configurable","_getPrototypeOf","o","arrayWithoutHoles","iterableToArray","nonIterableSpread","arrayLikeToArray","minLen","n","from","test","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","run","marker","runClearTimeout","Item","array","noop","nextTick","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","getNanoSeconds","hrtime","loadTime","moduleLoadTime","nodeLoadTime","upTime","performance","now","hr","uptime","Date","getTime","assertThisInitialized","_defineProperties","props","descriptor","enumerable","defineProperty","protoProps","staticProps","global","root","window","vendors","suffix","raf","caf","last","id","callback","_now","Math","max","cp","cancelled","round","cancel","polyfill","requestAnimationFrame","cancelAnimationFrame","_setPrototypeOf"],"mappings":"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","file":"deps/canvg.js","sourcesContent":["function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js\n// module id = 15tG\n// module chunks = 0471","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\n/* eslint-disable no-bitwise -- used for calculations */\n\n/* eslint-disable unicorn/prefer-query-selector -- aiming at\n  backward-compatibility */\n\n/**\n* StackBlur - a fast almost Gaussian Blur For Canvas\n*\n* In case you find this class useful - especially in commercial projects -\n* I am not totally unhappy for a small donation to my PayPal account\n* mario@quasimondo.de\n*\n* Or support me on flattr:\n* {@link https://flattr.com/thing/72791/StackBlur-a-fast-almost-Gaussian-Blur-Effect-for-CanvasJavascript}.\n*\n* @module StackBlur\n* @author Mario Klingemann\n* Contact: mario@quasimondo.com\n* Website: {@link http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html}\n* Twitter: @quasimondo\n*\n* @copyright (c) 2010 Mario Klingemann\n*\n* Permission is hereby granted, free of charge, to any person\n* obtaining a copy of this software and associated documentation\n* files (the \"Software\"), to deal in the Software without\n* restriction, including without limitation the rights to use,\n* copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the\n* Software is furnished to do so, subject to the following\n* conditions:\n*\n* The above copyright notice and this permission notice shall be\n* included in all copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n* OTHER DEALINGS IN THE SOFTWARE.\n*/\nvar mulTable = [512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271, 268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292, 289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259];\nvar shgTable = [9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24];\n/**\n * @param {string|HTMLImageElement} img\n * @param {string|HTMLCanvasElement} canvas\n * @param {Float} radius\n * @param {boolean} blurAlphaChannel\n * @param {boolean} useOffsetWidth\n * @returns {undefined}\n */\n\nfunction processImage(img, canvas, radius, blurAlphaChannel, useOffsetWidth) {\n  if (typeof img === 'string') {\n    img = document.getElementById(img);\n  }\n\n  if (!img || !('naturalWidth' in img)) {\n    return;\n  }\n\n  var dimensionType = useOffsetWidth ? 'offset' : 'natural';\n  var w = img[dimensionType + 'Width'];\n  var h = img[dimensionType + 'Height'];\n\n  if (typeof canvas === 'string') {\n    canvas = document.getElementById(canvas);\n  }\n\n  if (!canvas || !('getContext' in canvas)) {\n    return;\n  }\n\n  canvas.style.width = w + 'px';\n  canvas.style.height = h + 'px';\n  canvas.width = w;\n  canvas.height = h;\n  var context = canvas.getContext('2d');\n  context.clearRect(0, 0, w, h);\n  context.drawImage(img, 0, 0, img.naturalWidth, img.naturalHeight, 0, 0, w, h);\n\n  if (isNaN(radius) || radius < 1) {\n    return;\n  }\n\n  if (blurAlphaChannel) {\n    processCanvasRGBA(canvas, 0, 0, w, h, radius);\n  } else {\n    processCanvasRGB(canvas, 0, 0, w, h, radius);\n  }\n}\n/**\n * @param {string|HTMLCanvasElement} canvas\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @throws {Error|TypeError}\n * @returns {ImageData} See {@link https://html.spec.whatwg.org/multipage/canvas.html#imagedata}\n */\n\n\nfunction getImageDataFromCanvas(canvas, topX, topY, width, height) {\n  if (typeof canvas === 'string') {\n    canvas = document.getElementById(canvas);\n  }\n\n  if (!canvas || _typeof(canvas) !== 'object' || !('getContext' in canvas)) {\n    throw new TypeError('Expecting canvas with `getContext` method ' + 'in processCanvasRGB(A) calls!');\n  }\n\n  var context = canvas.getContext('2d');\n\n  try {\n    return context.getImageData(topX, topY, width, height);\n  } catch (e) {\n    throw new Error('unable to access image data: ' + e);\n  }\n}\n/**\n * @param {HTMLCanvasElement} canvas\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {undefined}\n */\n\n\nfunction processCanvasRGBA(canvas, topX, topY, width, height, radius) {\n  if (isNaN(radius) || radius < 1) {\n    return;\n  }\n\n  radius |= 0;\n  var imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);\n  imageData = processImageDataRGBA(imageData, topX, topY, width, height, radius);\n  canvas.getContext('2d').putImageData(imageData, topX, topY);\n}\n/**\n * @param {ImageData} imageData\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {ImageData}\n */\n\n\nfunction processImageDataRGBA(imageData, topX, topY, width, height, radius) {\n  var pixels = imageData.data;\n  var div = 2 * radius + 1; // const w4 = width << 2;\n\n  var widthMinus1 = width - 1;\n  var heightMinus1 = height - 1;\n  var radiusPlus1 = radius + 1;\n  var sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;\n  var stackStart = new BlurStack();\n  var stack = stackStart;\n  var stackEnd;\n\n  for (var i = 1; i < div; i++) {\n    stack = stack.next = new BlurStack();\n\n    if (i === radiusPlus1) {\n      stackEnd = stack;\n    }\n  }\n\n  stack.next = stackStart;\n  var stackIn = null,\n      stackOut = null,\n      yw = 0,\n      yi = 0;\n  var mulSum = mulTable[radius];\n  var shgSum = shgTable[radius];\n\n  for (var y = 0; y < height; y++) {\n    stack = stackStart;\n    var pr = pixels[yi],\n        pg = pixels[yi + 1],\n        pb = pixels[yi + 2],\n        pa = pixels[yi + 3];\n\n    for (var _i = 0; _i < radiusPlus1; _i++) {\n      stack.r = pr;\n      stack.g = pg;\n      stack.b = pb;\n      stack.a = pa;\n      stack = stack.next;\n    }\n\n    var rInSum = 0,\n        gInSum = 0,\n        bInSum = 0,\n        aInSum = 0,\n        rOutSum = radiusPlus1 * pr,\n        gOutSum = radiusPlus1 * pg,\n        bOutSum = radiusPlus1 * pb,\n        aOutSum = radiusPlus1 * pa,\n        rSum = sumFactor * pr,\n        gSum = sumFactor * pg,\n        bSum = sumFactor * pb,\n        aSum = sumFactor * pa;\n\n    for (var _i2 = 1; _i2 < radiusPlus1; _i2++) {\n      var p = yi + ((widthMinus1 < _i2 ? widthMinus1 : _i2) << 2);\n      var r = pixels[p],\n          g = pixels[p + 1],\n          b = pixels[p + 2],\n          a = pixels[p + 3];\n      var rbs = radiusPlus1 - _i2;\n      rSum += (stack.r = r) * rbs;\n      gSum += (stack.g = g) * rbs;\n      bSum += (stack.b = b) * rbs;\n      aSum += (stack.a = a) * rbs;\n      rInSum += r;\n      gInSum += g;\n      bInSum += b;\n      aInSum += a;\n      stack = stack.next;\n    }\n\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var x = 0; x < width; x++) {\n      var paInitial = aSum * mulSum >> shgSum;\n      pixels[yi + 3] = paInitial;\n\n      if (paInitial !== 0) {\n        var _a2 = 255 / paInitial;\n\n        pixels[yi] = (rSum * mulSum >> shgSum) * _a2;\n        pixels[yi + 1] = (gSum * mulSum >> shgSum) * _a2;\n        pixels[yi + 2] = (bSum * mulSum >> shgSum) * _a2;\n      } else {\n        pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;\n      }\n\n      rSum -= rOutSum;\n      gSum -= gOutSum;\n      bSum -= bOutSum;\n      aSum -= aOutSum;\n      rOutSum -= stackIn.r;\n      gOutSum -= stackIn.g;\n      bOutSum -= stackIn.b;\n      aOutSum -= stackIn.a;\n\n      var _p = x + radius + 1;\n\n      _p = yw + (_p < widthMinus1 ? _p : widthMinus1) << 2;\n      rInSum += stackIn.r = pixels[_p];\n      gInSum += stackIn.g = pixels[_p + 1];\n      bInSum += stackIn.b = pixels[_p + 2];\n      aInSum += stackIn.a = pixels[_p + 3];\n      rSum += rInSum;\n      gSum += gInSum;\n      bSum += bInSum;\n      aSum += aInSum;\n      stackIn = stackIn.next;\n      var _stackOut = stackOut,\n          _r = _stackOut.r,\n          _g = _stackOut.g,\n          _b = _stackOut.b,\n          _a = _stackOut.a;\n      rOutSum += _r;\n      gOutSum += _g;\n      bOutSum += _b;\n      aOutSum += _a;\n      rInSum -= _r;\n      gInSum -= _g;\n      bInSum -= _b;\n      aInSum -= _a;\n      stackOut = stackOut.next;\n      yi += 4;\n    }\n\n    yw += width;\n  }\n\n  for (var _x = 0; _x < width; _x++) {\n    yi = _x << 2;\n\n    var _pr = pixels[yi],\n        _pg = pixels[yi + 1],\n        _pb = pixels[yi + 2],\n        _pa = pixels[yi + 3],\n        _rOutSum = radiusPlus1 * _pr,\n        _gOutSum = radiusPlus1 * _pg,\n        _bOutSum = radiusPlus1 * _pb,\n        _aOutSum = radiusPlus1 * _pa,\n        _rSum = sumFactor * _pr,\n        _gSum = sumFactor * _pg,\n        _bSum = sumFactor * _pb,\n        _aSum = sumFactor * _pa;\n\n    stack = stackStart;\n\n    for (var _i3 = 0; _i3 < radiusPlus1; _i3++) {\n      stack.r = _pr;\n      stack.g = _pg;\n      stack.b = _pb;\n      stack.a = _pa;\n      stack = stack.next;\n    }\n\n    var yp = width;\n    var _gInSum = 0,\n        _bInSum = 0,\n        _aInSum = 0,\n        _rInSum = 0;\n\n    for (var _i4 = 1; _i4 <= radius; _i4++) {\n      yi = yp + _x << 2;\n\n      var _rbs = radiusPlus1 - _i4;\n\n      _rSum += (stack.r = _pr = pixels[yi]) * _rbs;\n      _gSum += (stack.g = _pg = pixels[yi + 1]) * _rbs;\n      _bSum += (stack.b = _pb = pixels[yi + 2]) * _rbs;\n      _aSum += (stack.a = _pa = pixels[yi + 3]) * _rbs;\n      _rInSum += _pr;\n      _gInSum += _pg;\n      _bInSum += _pb;\n      _aInSum += _pa;\n      stack = stack.next;\n\n      if (_i4 < heightMinus1) {\n        yp += width;\n      }\n    }\n\n    yi = _x;\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var _y = 0; _y < height; _y++) {\n      var _p2 = yi << 2;\n\n      pixels[_p2 + 3] = _pa = _aSum * mulSum >> shgSum;\n\n      if (_pa > 0) {\n        _pa = 255 / _pa;\n        pixels[_p2] = (_rSum * mulSum >> shgSum) * _pa;\n        pixels[_p2 + 1] = (_gSum * mulSum >> shgSum) * _pa;\n        pixels[_p2 + 2] = (_bSum * mulSum >> shgSum) * _pa;\n      } else {\n        pixels[_p2] = pixels[_p2 + 1] = pixels[_p2 + 2] = 0;\n      }\n\n      _rSum -= _rOutSum;\n      _gSum -= _gOutSum;\n      _bSum -= _bOutSum;\n      _aSum -= _aOutSum;\n      _rOutSum -= stackIn.r;\n      _gOutSum -= stackIn.g;\n      _bOutSum -= stackIn.b;\n      _aOutSum -= stackIn.a;\n      _p2 = _x + ((_p2 = _y + radiusPlus1) < heightMinus1 ? _p2 : heightMinus1) * width << 2;\n      _rSum += _rInSum += stackIn.r = pixels[_p2];\n      _gSum += _gInSum += stackIn.g = pixels[_p2 + 1];\n      _bSum += _bInSum += stackIn.b = pixels[_p2 + 2];\n      _aSum += _aInSum += stackIn.a = pixels[_p2 + 3];\n      stackIn = stackIn.next;\n      _rOutSum += _pr = stackOut.r;\n      _gOutSum += _pg = stackOut.g;\n      _bOutSum += _pb = stackOut.b;\n      _aOutSum += _pa = stackOut.a;\n      _rInSum -= _pr;\n      _gInSum -= _pg;\n      _bInSum -= _pb;\n      _aInSum -= _pa;\n      stackOut = stackOut.next;\n      yi += width;\n    }\n  }\n\n  return imageData;\n}\n/**\n * @param {HTMLCanvasElement} canvas\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {undefined}\n */\n\n\nfunction processCanvasRGB(canvas, topX, topY, width, height, radius) {\n  if (isNaN(radius) || radius < 1) {\n    return;\n  }\n\n  radius |= 0;\n  var imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);\n  imageData = processImageDataRGB(imageData, topX, topY, width, height, radius);\n  canvas.getContext('2d').putImageData(imageData, topX, topY);\n}\n/**\n * @param {ImageData} imageData\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {ImageData}\n */\n\n\nfunction processImageDataRGB(imageData, topX, topY, width, height, radius) {\n  var pixels = imageData.data;\n  var div = 2 * radius + 1; // const w4 = width << 2;\n\n  var widthMinus1 = width - 1;\n  var heightMinus1 = height - 1;\n  var radiusPlus1 = radius + 1;\n  var sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;\n  var stackStart = new BlurStack();\n  var stack = stackStart;\n  var stackEnd;\n\n  for (var i = 1; i < div; i++) {\n    stack = stack.next = new BlurStack();\n\n    if (i === radiusPlus1) {\n      stackEnd = stack;\n    }\n  }\n\n  stack.next = stackStart;\n  var stackIn = null;\n  var stackOut = null;\n  var mulSum = mulTable[radius];\n  var shgSum = shgTable[radius];\n  var p, rbs;\n  var yw = 0,\n      yi = 0;\n\n  for (var y = 0; y < height; y++) {\n    var pr = pixels[yi],\n        pg = pixels[yi + 1],\n        pb = pixels[yi + 2],\n        rOutSum = radiusPlus1 * pr,\n        gOutSum = radiusPlus1 * pg,\n        bOutSum = radiusPlus1 * pb,\n        rSum = sumFactor * pr,\n        gSum = sumFactor * pg,\n        bSum = sumFactor * pb;\n    stack = stackStart;\n\n    for (var _i5 = 0; _i5 < radiusPlus1; _i5++) {\n      stack.r = pr;\n      stack.g = pg;\n      stack.b = pb;\n      stack = stack.next;\n    }\n\n    var rInSum = 0,\n        gInSum = 0,\n        bInSum = 0;\n\n    for (var _i6 = 1; _i6 < radiusPlus1; _i6++) {\n      p = yi + ((widthMinus1 < _i6 ? widthMinus1 : _i6) << 2);\n      rSum += (stack.r = pr = pixels[p]) * (rbs = radiusPlus1 - _i6);\n      gSum += (stack.g = pg = pixels[p + 1]) * rbs;\n      bSum += (stack.b = pb = pixels[p + 2]) * rbs;\n      rInSum += pr;\n      gInSum += pg;\n      bInSum += pb;\n      stack = stack.next;\n    }\n\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var x = 0; x < width; x++) {\n      pixels[yi] = rSum * mulSum >> shgSum;\n      pixels[yi + 1] = gSum * mulSum >> shgSum;\n      pixels[yi + 2] = bSum * mulSum >> shgSum;\n      rSum -= rOutSum;\n      gSum -= gOutSum;\n      bSum -= bOutSum;\n      rOutSum -= stackIn.r;\n      gOutSum -= stackIn.g;\n      bOutSum -= stackIn.b;\n      p = yw + ((p = x + radius + 1) < widthMinus1 ? p : widthMinus1) << 2;\n      rInSum += stackIn.r = pixels[p];\n      gInSum += stackIn.g = pixels[p + 1];\n      bInSum += stackIn.b = pixels[p + 2];\n      rSum += rInSum;\n      gSum += gInSum;\n      bSum += bInSum;\n      stackIn = stackIn.next;\n      rOutSum += pr = stackOut.r;\n      gOutSum += pg = stackOut.g;\n      bOutSum += pb = stackOut.b;\n      rInSum -= pr;\n      gInSum -= pg;\n      bInSum -= pb;\n      stackOut = stackOut.next;\n      yi += 4;\n    }\n\n    yw += width;\n  }\n\n  for (var _x2 = 0; _x2 < width; _x2++) {\n    yi = _x2 << 2;\n\n    var _pr2 = pixels[yi],\n        _pg2 = pixels[yi + 1],\n        _pb2 = pixels[yi + 2],\n        _rOutSum2 = radiusPlus1 * _pr2,\n        _gOutSum2 = radiusPlus1 * _pg2,\n        _bOutSum2 = radiusPlus1 * _pb2,\n        _rSum2 = sumFactor * _pr2,\n        _gSum2 = sumFactor * _pg2,\n        _bSum2 = sumFactor * _pb2;\n\n    stack = stackStart;\n\n    for (var _i7 = 0; _i7 < radiusPlus1; _i7++) {\n      stack.r = _pr2;\n      stack.g = _pg2;\n      stack.b = _pb2;\n      stack = stack.next;\n    }\n\n    var _rInSum2 = 0,\n        _gInSum2 = 0,\n        _bInSum2 = 0;\n\n    for (var _i8 = 1, yp = width; _i8 <= radius; _i8++) {\n      yi = yp + _x2 << 2;\n      _rSum2 += (stack.r = _pr2 = pixels[yi]) * (rbs = radiusPlus1 - _i8);\n      _gSum2 += (stack.g = _pg2 = pixels[yi + 1]) * rbs;\n      _bSum2 += (stack.b = _pb2 = pixels[yi + 2]) * rbs;\n      _rInSum2 += _pr2;\n      _gInSum2 += _pg2;\n      _bInSum2 += _pb2;\n      stack = stack.next;\n\n      if (_i8 < heightMinus1) {\n        yp += width;\n      }\n    }\n\n    yi = _x2;\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var _y2 = 0; _y2 < height; _y2++) {\n      p = yi << 2;\n      pixels[p] = _rSum2 * mulSum >> shgSum;\n      pixels[p + 1] = _gSum2 * mulSum >> shgSum;\n      pixels[p + 2] = _bSum2 * mulSum >> shgSum;\n      _rSum2 -= _rOutSum2;\n      _gSum2 -= _gOutSum2;\n      _bSum2 -= _bOutSum2;\n      _rOutSum2 -= stackIn.r;\n      _gOutSum2 -= stackIn.g;\n      _bOutSum2 -= stackIn.b;\n      p = _x2 + ((p = _y2 + radiusPlus1) < heightMinus1 ? p : heightMinus1) * width << 2;\n      _rSum2 += _rInSum2 += stackIn.r = pixels[p];\n      _gSum2 += _gInSum2 += stackIn.g = pixels[p + 1];\n      _bSum2 += _bInSum2 += stackIn.b = pixels[p + 2];\n      stackIn = stackIn.next;\n      _rOutSum2 += _pr2 = stackOut.r;\n      _gOutSum2 += _pg2 = stackOut.g;\n      _bOutSum2 += _pb2 = stackOut.b;\n      _rInSum2 -= _pr2;\n      _gInSum2 -= _pg2;\n      _bInSum2 -= _pb2;\n      stackOut = stackOut.next;\n      yi += width;\n    }\n  }\n\n  return imageData;\n}\n/**\n *\n */\n\n\nvar BlurStack =\n/**\n * Set properties.\n */\nfunction BlurStack() {\n  _classCallCheck(this, BlurStack);\n\n  this.r = 0;\n  this.g = 0;\n  this.b = 0;\n  this.a = 0;\n  this.next = null;\n};\n\nexport { BlurStack, processCanvasRGB as canvasRGB, processCanvasRGBA as canvasRGBA, processImage as image, processImageDataRGB as imageDataRGB, processImageDataRGBA as imageDataRGBA };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/stackblur-canvas/dist/stackblur-es.js\n// module id = 2gqV\n// module chunks = 0471","/*\n\tBased on rgbcolor.js by Stoyan Stefanov <sstoo@gmail.com>\n\thttp://www.phpied.com/rgb-color-parser-in-javascript/\n*/\n\nmodule.exports = function(color_string) {\n    this.ok = false;\n    this.alpha = 1.0;\n\n    // strip any leading #\n    if (color_string.charAt(0) == '#') { // remove # if any\n        color_string = color_string.substr(1,6);\n    }\n\n    color_string = color_string.replace(/ /g,'');\n    color_string = color_string.toLowerCase();\n\n    // before getting into regexps, try simple matches\n    // and overwrite the input\n    var simple_colors = {\n        aliceblue: 'f0f8ff',\n        antiquewhite: 'faebd7',\n        aqua: '00ffff',\n        aquamarine: '7fffd4',\n        azure: 'f0ffff',\n        beige: 'f5f5dc',\n        bisque: 'ffe4c4',\n        black: '000000',\n        blanchedalmond: 'ffebcd',\n        blue: '0000ff',\n        blueviolet: '8a2be2',\n        brown: 'a52a2a',\n        burlywood: 'deb887',\n        cadetblue: '5f9ea0',\n        chartreuse: '7fff00',\n        chocolate: 'd2691e',\n        coral: 'ff7f50',\n        cornflowerblue: '6495ed',\n        cornsilk: 'fff8dc',\n        crimson: 'dc143c',\n        cyan: '00ffff',\n        darkblue: '00008b',\n        darkcyan: '008b8b',\n        darkgoldenrod: 'b8860b',\n        darkgray: 'a9a9a9',\n        darkgreen: '006400',\n        darkkhaki: 'bdb76b',\n        darkmagenta: '8b008b',\n        darkolivegreen: '556b2f',\n        darkorange: 'ff8c00',\n        darkorchid: '9932cc',\n        darkred: '8b0000',\n        darksalmon: 'e9967a',\n        darkseagreen: '8fbc8f',\n        darkslateblue: '483d8b',\n        darkslategray: '2f4f4f',\n        darkturquoise: '00ced1',\n        darkviolet: '9400d3',\n        deeppink: 'ff1493',\n        deepskyblue: '00bfff',\n        dimgray: '696969',\n        dodgerblue: '1e90ff',\n        feldspar: 'd19275',\n        firebrick: 'b22222',\n        floralwhite: 'fffaf0',\n        forestgreen: '228b22',\n        fuchsia: 'ff00ff',\n        gainsboro: 'dcdcdc',\n        ghostwhite: 'f8f8ff',\n        gold: 'ffd700',\n        goldenrod: 'daa520',\n        gray: '808080',\n        green: '008000',\n        greenyellow: 'adff2f',\n        honeydew: 'f0fff0',\n        hotpink: 'ff69b4',\n        indianred : 'cd5c5c',\n        indigo : '4b0082',\n        ivory: 'fffff0',\n        khaki: 'f0e68c',\n        lavender: 'e6e6fa',\n        lavenderblush: 'fff0f5',\n        lawngreen: '7cfc00',\n        lemonchiffon: 'fffacd',\n        lightblue: 'add8e6',\n        lightcoral: 'f08080',\n        lightcyan: 'e0ffff',\n        lightgoldenrodyellow: 'fafad2',\n        lightgrey: 'd3d3d3',\n        lightgreen: '90ee90',\n        lightpink: 'ffb6c1',\n        lightsalmon: 'ffa07a',\n        lightseagreen: '20b2aa',\n        lightskyblue: '87cefa',\n        lightslateblue: '8470ff',\n        lightslategray: '778899',\n        lightsteelblue: 'b0c4de',\n        lightyellow: 'ffffe0',\n        lime: '00ff00',\n        limegreen: '32cd32',\n        linen: 'faf0e6',\n        magenta: 'ff00ff',\n        maroon: '800000',\n        mediumaquamarine: '66cdaa',\n        mediumblue: '0000cd',\n        mediumorchid: 'ba55d3',\n        mediumpurple: '9370d8',\n        mediumseagreen: '3cb371',\n        mediumslateblue: '7b68ee',\n        mediumspringgreen: '00fa9a',\n        mediumturquoise: '48d1cc',\n        mediumvioletred: 'c71585',\n        midnightblue: '191970',\n        mintcream: 'f5fffa',\n        mistyrose: 'ffe4e1',\n        moccasin: 'ffe4b5',\n        navajowhite: 'ffdead',\n        navy: '000080',\n        oldlace: 'fdf5e6',\n        olive: '808000',\n        olivedrab: '6b8e23',\n        orange: 'ffa500',\n        orangered: 'ff4500',\n        orchid: 'da70d6',\n        palegoldenrod: 'eee8aa',\n        palegreen: '98fb98',\n        paleturquoise: 'afeeee',\n        palevioletred: 'd87093',\n        papayawhip: 'ffefd5',\n        peachpuff: 'ffdab9',\n        peru: 'cd853f',\n        pink: 'ffc0cb',\n        plum: 'dda0dd',\n        powderblue: 'b0e0e6',\n        purple: '800080',\n        rebeccapurple: '663399',\n        red: 'ff0000',\n        rosybrown: 'bc8f8f',\n        royalblue: '4169e1',\n        saddlebrown: '8b4513',\n        salmon: 'fa8072',\n        sandybrown: 'f4a460',\n        seagreen: '2e8b57',\n        seashell: 'fff5ee',\n        sienna: 'a0522d',\n        silver: 'c0c0c0',\n        skyblue: '87ceeb',\n        slateblue: '6a5acd',\n        slategray: '708090',\n        snow: 'fffafa',\n        springgreen: '00ff7f',\n        steelblue: '4682b4',\n        tan: 'd2b48c',\n        teal: '008080',\n        thistle: 'd8bfd8',\n        tomato: 'ff6347',\n        turquoise: '40e0d0',\n        violet: 'ee82ee',\n        violetred: 'd02090',\n        wheat: 'f5deb3',\n        white: 'ffffff',\n        whitesmoke: 'f5f5f5',\n        yellow: 'ffff00',\n        yellowgreen: '9acd32'\n    };\n    color_string = simple_colors[color_string] || color_string;\n    // emd of simple type-in colors\n\n    // array of color definition objects\n    var color_defs = [\n        {\n            re: /^rgba\\((\\d{1,3}),\\s*(\\d{1,3}),\\s*(\\d{1,3}),\\s*((?:\\d?\\.)?\\d)\\)$/,\n            example: ['rgba(123, 234, 45, 0.8)', 'rgba(255,234,245,1.0)'],\n            process: function (bits){\n                return [\n                    parseInt(bits[1]),\n                    parseInt(bits[2]),\n                    parseInt(bits[3]),\n                    parseFloat(bits[4])\n                ];\n            }\n        },\n        {\n            re: /^rgb\\((\\d{1,3}),\\s*(\\d{1,3}),\\s*(\\d{1,3})\\)$/,\n            example: ['rgb(123, 234, 45)', 'rgb(255,234,245)'],\n            process: function (bits){\n                return [\n                    parseInt(bits[1]),\n                    parseInt(bits[2]),\n                    parseInt(bits[3])\n                ];\n            }\n        },\n        {\n            re: /^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,\n            example: ['#00ff00', '336699'],\n            process: function (bits){\n                return [\n                    parseInt(bits[1], 16),\n                    parseInt(bits[2], 16),\n                    parseInt(bits[3], 16)\n                ];\n            }\n        },\n        {\n            re: /^([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n            example: ['#fb0', 'f0f'],\n            process: function (bits){\n                return [\n                    parseInt(bits[1] + bits[1], 16),\n                    parseInt(bits[2] + bits[2], 16),\n                    parseInt(bits[3] + bits[3], 16)\n                ];\n            }\n        }\n    ];\n\n    // search through the definitions to find a match\n    for (var i = 0; i < color_defs.length; i++) {\n        var re = color_defs[i].re;\n        var processor = color_defs[i].process;\n        var bits = re.exec(color_string);\n        if (bits) {\n            var channels = processor(bits);\n            this.r = channels[0];\n            this.g = channels[1];\n            this.b = channels[2];\n            if (channels.length > 3) {\n                this.alpha = channels[3];\n            }\n            this.ok = true;\n        }\n\n    }\n\n    // validate/cleanup values\n    this.r = (this.r < 0 || isNaN(this.r)) ? 0 : ((this.r > 255) ? 255 : this.r);\n    this.g = (this.g < 0 || isNaN(this.g)) ? 0 : ((this.g > 255) ? 255 : this.g);\n    this.b = (this.b < 0 || isNaN(this.b)) ? 0 : ((this.b > 255) ? 255 : this.b);\n    this.alpha = (this.alpha < 0) ? 0 : ((this.alpha > 1.0 || isNaN(this.alpha)) ? 1.0 : this.alpha);\n\n    // some getters\n    this.toRGB = function () {\n        return 'rgb(' + this.r + ', ' + this.g + ', ' + this.b + ')';\n    }\n    this.toRGBA = function () {\n        return 'rgba(' + this.r + ', ' + this.g + ', ' + this.b + ', ' + this.alpha + ')';\n    }\n    this.toHex = function () {\n        var r = this.r.toString(16);\n        var g = this.g.toString(16);\n        var b = this.b.toString(16);\n        if (r.length == 1) r = '0' + r;\n        if (g.length == 1) g = '0' + g;\n        if (b.length == 1) b = '0' + b;\n        return '#' + r + g + b;\n    }\n\n    // help\n    this.getHelpXML = function () {\n\n        var examples = new Array();\n        // add regexps\n        for (var i = 0; i < color_defs.length; i++) {\n            var example = color_defs[i].example;\n            for (var j = 0; j < example.length; j++) {\n                examples[examples.length] = example[j];\n            }\n        }\n        // add type-in colors\n        for (var sc in simple_colors) {\n            examples[examples.length] = sc;\n        }\n\n        var xml = document.createElement('ul');\n        xml.setAttribute('id', 'rgbcolor-examples');\n        for (var i = 0; i < examples.length; i++) {\n            try {\n                var list_item = document.createElement('li');\n                var list_color = new RGBColor(examples[i]);\n                var example_div = document.createElement('div');\n                example_div.style.cssText =\n                        'margin: 3px; '\n                        + 'border: 1px solid black; '\n                        + 'background:' + list_color.toHex() + '; '\n                        + 'color:' + list_color.toHex()\n                ;\n                example_div.appendChild(document.createTextNode('test'));\n                var list_item_value = document.createTextNode(\n                    ' ' + examples[i] + ' -> ' + list_color.toRGB() + ' -> ' + list_color.toHex()\n                );\n                list_item.appendChild(example_div);\n                list_item.appendChild(list_item_value);\n                xml.appendChild(list_item);\n\n            } catch(e){}\n        }\n        return xml;\n\n    }\n\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/rgbcolor/index.js\n// module id = 4E4r\n// module chunks = 0471","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/arrayLikeToArray.js\n// module id = 4WZ4\n// module chunks = 0471","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n\n\n\n// WEBPACK FOOTER //\n// ../node_modules/regenerator-runtime/runtime.js","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/assertThisInitialized.js\n// module id = AKLy\n// module chunks = 0471","module.exports = require(\"regenerator-runtime\");\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/regenerator/index.js\n// module id = FOhS\n// module chunks = 0471","var superPropBase = require(\"./superPropBase\");\n\nfunction _get(target, property, receiver) {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get(target, property, receiver || target);\n}\n\nmodule.exports = _get;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/get.js\n// module id = GUmJ\n// module chunks = 0471","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/asyncToGenerator.js\n// module id = Gd1W\n// module chunks = 0471","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/arrayWithHoles.js\n// module id = KED7\n// module chunks = 0471","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}\n\nmodule.exports = _superPropBase;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/superPropBase.js\n// module id = Lilp\n// module chunks = 0471","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/slicedToArray.js\n// module id = MGDH\n// module chunks = 0471","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/inherits.js\n// module id = QUJ4\n// module chunks = 0471","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/nonIterableSpread.js\n// module id = RAmp\n// module chunks = 0471","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/getPrototypeOf.js\n// module id = RXKi\n// module chunks = 0471","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/toConsumableArray.js\n// module id = S9/t\n// module chunks = 0471","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/nonIterableRest.js\n// module id = UqQ9\n// module chunks = 0471","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js\n// module id = Wd1Q\n// module chunks = 0471","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // 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\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // 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.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/process/browser.js\n// module id = Xm2t\n// module chunks = 076f 0471 bf3e","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/iterableToArray.js\n// module id = bOmF\n// module chunks = 0471","if performance? and performance.now\n  module.exports = -> performance.now()\nelse if process? and process.hrtime\n  module.exports = -> (getNanoSeconds() - nodeLoadTime) / 1e6\n  hrtime = process.hrtime\n  getNanoSeconds = ->\n    hr = hrtime()\n    hr[0] * 1e9 + hr[1]\n  moduleLoadTime = getNanoSeconds()\n  upTime = process.uptime() * 1e9\n  nodeLoadTime = moduleLoadTime - upTime\nelse if Date.now\n  module.exports = -> Date.now() - loadTime\n  loadTime = Date.now()\nelse\n  module.exports = -> new Date().getTime() - loadTime\n  loadTime = new Date().getTime()\n\n\n\n// WEBPACK FOOTER //\n// C:/Dropbox/www/amcharts4dev/node_modules/performance-now/src/performance-now.coffee","var _typeof = require(\"../helpers/typeof\");\n\nvar assertThisInitialized = require(\"./assertThisInitialized\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js\n// module id = eYbk\n// module chunks = 0471","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/createClass.js\n// module id = gqWF\n// module chunks = 0471","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/raf/index.js\n// module id = kdhv\n// module chunks = 0471","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/defineProperty.js\n// module id = l3u9\n// module chunks = 0471","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js\n// module id = qj8e\n// module chunks = 0471","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/setPrototypeOf.js\n// module id = r1fo\n// module chunks = 0471","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/classCallCheck.js\n// module id = v2Fs\n// module chunks = 0471","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/Dropbox/www/amcharts4dev/node_modules/@babel/runtime/helpers/typeof.js\n// module id = wSZt\n// module chunks = 0471"],"sourceRoot":""}