{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","vizicities-worker.min.js","webpack:/webpack/bootstrap 8912944b678b5a293f37","webpack:///src/vizicities-worker.js","webpack:///src/geo/Geo.js","webpack:///src/geo/LatLon.js","webpack:///src/geo/Point.js","webpack:///src/layer/Layer.js","webpack:///~/eventemitter3/index.js","webpack:///~/lodash.assign/index.js","webpack:///~/lodash.keys/index.js","webpack:///~/lodash.rest/index.js","webpack:///~/shortid/index.js","webpack:///~/shortid/lib/index.js","webpack:///~/shortid/lib/alphabet.js","webpack:///~/shortid/lib/random/random-from-seed.js","webpack:///~/shortid/lib/encode.js","webpack:///~/shortid/lib/random/random-byte-browser.js","webpack:///~/shortid/lib/decode.js","webpack:///~/shortid/lib/is-valid.js","webpack:///~/shortid/lib/util/cluster-worker-id-browser.js","webpack:/external \"THREE\"","webpack:///src/engine/Scene.js","webpack:///src/vendor/CSS3DRenderer.js","webpack:///src/vendor/CSS2DRenderer.js","webpack:///src/layer/GeoJSONWorkerLayer.js","webpack:///~/reqwest/reqwest.js","webpack:///src/util/GeoJSON.js","webpack:///~/topojson/build/topojson.js","webpack:///~/geojson-merge/index.js","webpack:///~/geojson-normalize/index.js","webpack:///~/earcut/src/earcut.js","webpack:///src/util/extrudePolygon.js","webpack:///src/util/Worker.js","webpack:///src/util/WorkerPool.js","webpack:///src/util/WorkerPoolWorker.js","webpack:///src/util/Buffer.js","webpack:///src/util/Stringify.js","webpack:///src/layer/geometry/PolygonLayer.js","webpack:///src/engine/PickingMaterial.js","webpack:///src/engine/PickingShader.js","webpack:///src/layer/geometry/PolylineLayer.js","webpack:///src/layer/geometry/PointLayer.js","webpack:///src/util/index.js","webpack:///src/util/wrapNum.js"],"names":["root","factory","exports","module","require","define","amd","this","__WEBPACK_EXTERNAL_MODULE_18__","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","_interopRequireDefault","obj","__esModule","default","Object","defineProperty","value","_geoGeoJs","_geoGeoJs2","_layerLayer","_layerLayer2","_layerGeoJSONWorkerLayer","_layerGeoJSONWorkerLayer2","_layerGeometryPolygonLayer","_layerGeometryPolygonLayer2","_geoPoint","_geoPoint2","_geoLatLon","_geoLatLon2","_utilIndex","_utilIndex2","VIZI","version","Geo","Layer","layer","GeoJSONWorkerLayer","geoJSONWorkerLayer","PolygonLayer","polygonLayer","Point","point","LatLon","latLon","Util","_LatLon","_Point","R","MAX_LATITUDE","ECC","ECC2","project","latlon","d","Math","PI","max","lat","min","sin","lon","log","unproject","atan","exp","y","x","latLonToPoint","projected","pointToLatLon","_point","pointScale","accurate","k","rad","a","sinLat","sinLat2","cosLat","cos","pow","v","sqrt","h","metresToProjected","metres","projectedToMetres","projectedUnits","metresToWorld","projectedMetres","scale","scaledMetres","worldToMetres","worldUnits","realMetres","zoom","LN2","distance","latlon1","latlon2","lat1","lat2","lon1","lon2","deltaLat","deltaLon","halfDeltaLat","halfDeltaLon","atan2","acos","bounds","_classCallCheck","instance","Constructor","TypeError","_createClass","defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","key","protoProps","staticProps","prototype","alt","isNaN","Error","undefined","noNew","b","Array","isArray","lng","round","clone","_add","_subtract","_inherits","subClass","superClass","create","constructor","setPrototypeOf","__proto__","_get","_x","_x2","_x3","_again","object","property","receiver","Function","desc","getOwnPropertyDescriptor","getter","get","parent","getPrototypeOf","_eventemitter3","_eventemitter32","_lodashAssign","_lodashAssign2","_shortid","_shortid2","_three","_three2","_engineScene","_vendorCSS3DRenderer","_vendorCSS2DRenderer","_EventEmitter","options","defaults","generate","output","outputToScene","_options","isOutput","_object3D","Object3D","_dom3D","document","createElement","_domObject3D","CSS3DObject","_dom2D","_domObject2D","CSS2DObject","add","remove","world","addLayer","_this","_world","Promise","resolve","reject","_onAdd","then","emit","_engine","_picking","getNextId","visible","_pickingMesh","children","child","geometry","dispose","material","map","removeDOM3D","removeDOM2D","EE","fn","context","once","EventEmitter","has","hasOwnProperty","prefix","_events","eventNames","name","events","names","push","slice","getOwnPropertySymbols","concat","listeners","event","exists","evt","available","l","ee","a1","a2","a3","a4","a5","args","len","arguments","removeListener","apply","j","on","listener","removeAllListeners","off","addListener","setMaxListeners","prefixed","assignValue","objValue","eq","baseProperty","copyObject","source","customizer","index","newValue","createAssigner","assigner","rest","sources","guard","isIterateeCall","isIndex","MAX_SAFE_INTEGER","reIsUint","test","isObject","type","isArrayLike","isPrototype","Ctor","proto","objectProto","other","isLength","getLength","isFunction","tag","objectToString","funcTag","genTag","keys","toString","propertyIsEnumerable","nonEnumShadows","valueOf","assign","baseTimes","n","iteratee","result","baseHas","getPrototype","baseKeys","nativeKeys","nativeGetPrototype","indexKeys","isString","isArguments","String","isArrayLikeObject","argsTag","isObjectLike","stringTag","isProto","indexes","skipIndexes","func","thisArg","start","FUNC_ERROR_TEXT","nativeMax","toInteger","array","otherArgs","isSymbol","symbolTag","toFinite","toNumber","INFINITY","sign","MAX_INTEGER","remainder","NAN","replace","reTrim","isBinary","reIsBinary","reIsOctal","freeParseInt","reIsBadHex","parseInt","str","seconds","floor","Date","now","REDUCE_TIME","previousSeconds","counter","encode","alphabet","lookup","clusterWorkerId","seed","seedValue","worker","workerId","characters","newCharacters","shuffled","decode","isValid","reset","setCharacters","_alphabet_","ORIGINAL","unique","split","filter","item","ind","arr","lastIndexOf","join","setSeed","randomFromSeed","previousSeed","shuffle","characterIndex","sourceArray","targetArray","r","nextValue","splice","getShuffled","alphabetShuffled","getNextValue","_seed_","number","done","loopCounter","randomByte","crypto","getRandomValues","random","dest","Uint8Array","window","msCrypto","indexOf","substr","isShortId","scene","Scene","element","style","position","addEventListener","parentNode","removeChild","CSS3DSprite","CSS3DRenderer","console","REVISION","_width","_height","_widthHalf","_heightHalf","matrix","Matrix4","cache","camera","fov","objects","domElement","overflow","WebkitTransformStyle","MozTransformStyle","oTransformStyle","transformStyle","cameraElement","appendChild","setClearColor","getSize","width","height","setSize","epsilon","abs","Number","EPSILON","getCameraCSSMatrix","elements","getObjectCSSMatrix","renderObject","copy","matrixWorldInverse","transpose","copyPosition","matrixWorld","cachedStyle","WebkitTransform","MozTransform","oTransform","transform","render","tan","degToRad","WebkitPerspective","MozPerspective","oPerspective","perspective","updateMatrixWorld","getInverse","CSS2DRenderer","vector","Vector3","viewMatrix","viewProjectionMatrix","frustum","Frustum","setFromMatrixPosition","applyProjection","containsPoint","display","multiplyMatrices","projectionMatrix","setFromMatrix","_slicedToArray","sliceIterator","_arr","_n","_d","_e","_s","_i","Symbol","iterator","next","err","_Layer2","_Layer3","_reqwest","_reqwest2","_utilGeoJSON","_utilGeoJSON2","_utilWorker","_utilWorker2","_utilBuffer","_utilBuffer2","_utilStringify","_utilStringify2","_geometryPolygonLayer","_geometryPolygonLayer2","_geometryPolylineLayer","_geometryPolylineLayer2","_geometryPointLayer","_geometryPointLayer2","_geoGeo","_geoGeo2","_enginePickingMaterial","_Layer","geojson","topojson","defaultStyle","onEachFeature","onEachFeatureWorker","onAddAttributes","interactive","pointGeometry","onClick","headers","_aborted","_geojson","THREE","_process","functionToString","transferrables","stringToUint8Array","JSON","stringify","buffer","_execWorker","_originPoint","RequestGeoJSON","res","fc","collectFeatures","features","feature","originPoint","_this2","time","exec","results","timeEnd","processPromises","polygons","_processPolygonResults","polylines","_processPolylineResults","points","_processPointResults","all","_this3","splitOutlinePositions","splitOutlineColors","splitPositions","splitFloat32Array","attributes","positions","splitNormals","normals","splitColors","colors","splitTops","tops","outlineAttributes","splitProperties","properties","splitUint8Array","pickingId","pickingIds","flats","outlineObjects","polygonAttributeLengths","polygonOutlineAttributeLengths","parse","uint8ArrayToString","flat","getPickingId","Float32Array","fill","_addPicking","customAttribute","customAttributes","polygonAttributes","polygonOutlineAttributes","polygonFlat","bufferAttributes","mergeAttributes","outputPromises","mergedPolygonAttributes","_setPolygonMesh","mergedPolygonOutlineAttributes","outlineRenderOrder","lineRenderOrder","renderOrder","outlineWidth","lineWidth","_setPolylineMesh","_results","polygonResult","outlineResult","_polygonMesh","mesh","pickingMesh","_this4","polylineAttributeLengths","polylineAttributes","polylineFlat","mergedPolylineAttributes","_polylineMesh","_this5","pointAttributeLengths","pointAttributes","pointFlat","mergedPointAttributes","_setPointMesh","_pointMesh","attributeLengths","SetMesh","_environment","_skybox","_this6","point2d","point3d","intersects","_style","_properties","_pointGeometry","ProcessGeoJSON","stringToFunction","coordinates","isSingle","converted","_coordinates","ring","coordinate","polygon","polyline","polygonBufferPromises","polylineBufferPromises","pointBufferPromises","SetBufferAttributes","data","ProcessPolygons","ProcessPolylines","ProcessPoints","polygonPromises","outlinePositions","outlineColors","mergedAttributes","mergeFloat32Arrays","mergedOutlineAttributes","mergedProperties","mergeUint8Arrays","polylinePromises","pointPromises","path","url","crossOrigin","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_RESULT__","definition","succeed","protocol","protocolRe","location","httpsRe","twoHundo","request","status","response","handleReadyState","success","error","_timedOut","readyState","onreadystatechange","noop","setHeaders","http","o","defaultHeaders","isAFormData","FormData","requestedWith","contentType","setRequestHeader","setCredentials","withCredentials","generalCallback","lastValue","urlappend","s","handleJsonp","reqId","uniqid","cbkey","cbval","reqwest","getcallbackPrefix","cbreg","RegExp","match","script","doc","isIE10","navigator","userAgent","src","async","htmlFor","onload","onclick","head","abort","getRequest","method","toUpperCase","toQueryString","sendWait","xhr","open","xDomainRequest","onerror","onprogress","setTimeout","send","Reqwest","init","setType","header","complete","resp","clearTimeout","self","timeout","_completeHandlers","shift","getResponseHeader","filteredResponse","globalSetupOptions","dataFilter","responseText","e","eval","responseXML","parseError","errorCode","reason","_responseArgs","_fulfilled","_successHandler","_fulfillmentHandlers","timedOut","msg","t","_erred","_errorHandlers","normalize","serial","el","cb","ch","ra","val","tagName","toLowerCase","optCb","disabled","checked","selectedIndex","selected","eachFormElement","serializeSubtags","tags","fa","byTag","serializeQueryString","serializeArray","serializeHash","hash","buildParams","traditional","rbracket","XHR2","ex","callbackPrefix","xmlHttpRequest","accept","*","xml","html","text","json","js","XMLHttpRequest","XDomainRequest","ActiveXObject","retry","fail","always","catch","serialize","opt","pop","nodeType","trad","enc","encodeURIComponent","compat","ajaxSetup","_interopRequireWildcard","newObj","_topojson2","_geojsonMerge","_geojsonMerge2","_earcut","_earcut2","_extrudePolygon","_extrudePolygon2","light","Color","shadow","GeoJSON","color","outline","outlineColor","transparent","opacity","blending","NormalBlending","lineOpacity","lineTransparent","lineColor","lineBlending","_topojson","collections","tk","gk","lineStringAttributes","colour","nextCoord","_coords","_colours","forEach","g","vertices","colours","multiLineStringAttributes","coord","earcutData","_toEarcut","faces","_triangulate","holes","dimensions","groupedVertices","il","_colour","extruded","bottom","top","topColor","multiply","bottomColor","_vertices","_faces","face","fi","allFlat","sides","dim","holeIndex","contour","global","transformAbsolute","x0","y0","kx","ky","dx","translate","dy","transformRelative","x1","y1","reverse","bisect","lo","hi","mid","topology","geometries","feature$1","f","arc","arcs","absolute","line","geometryType","MultiPoint","LineString","MultiLineString","Polygon","MultiPolygon","stitchArcs","ends","p1","p0","dp","flush","fragmentByEnd","fragmentByStart","end","stitchedArcs","fragments","emptyIndex","fg","unshift","gf","meshArcs","geomsByArc","geom","geoms","cartesianTriangleArea","triangle","area","merge","mergeArcs","register","ring$$","polygonsByArc","components","_","component","neighbors","ki","indexesByArc","ij","ik","compareArea","minAreaHeap","up","down","size","heap","removed","presimplify","triangleArea","update","relative","triangles","maxArea","Infinity","previous","inputs","reduce","memo","input","gj","types","GeometryCollection","Feature","FeatureCollection","earcut","holeIndices","hasHoles","outerLen","outerNode","linkedList","minX","minY","maxX","maxY","eliminateHoles","earcutLinked","clockwise","last","signedArea","insertNode","equals","removeNode","filterPoints","again","steiner","prev","ear","pass","indexCurve","stop","isEarHashed","isEar","cureLocalIntersections","splitEarcut","pointInTriangle","minTX","minTY","maxTX","maxTY","minZ","zOrder","maxZ","nextZ","z","prevZ","locallyInside","isValidDiagonal","splitPolygon","list","queue","getLeftmost","sort","compareX","eliminateHole","hole","findHoleBridge","hx","hy","qx","mx","my","tanMin","sortLinked","q","tail","numMerges","pSize","qSize","inSize","leftmost","ax","ay","bx","by","cx","cy","px","py","intersectsPolygon","middleInside","p2","q1","q2","inside","Node","b2","an","bp","sum","deviation","polygonArea","trianglesArea","flatten","extrudePolygon","cells","topCells","full","sideCells","closed","bottomCells","_WorkerPool","_WorkerPool2","Worker","pool","_maxWorkers","createWorkers","maxWorkers","workerScript","numThreads","_WorkerPoolWorker","_WorkerPoolWorker2","DEBUG","WorkerPool","workers","tasks","workerPromises","createWorker","performance","find","busy","deferred","task","processTasks","promise","getFreeWorker","WorkerPoolWorker","ready","onStartup","removeEventListener","onMessage","postMessage","payload","Buffer","arrays","Int32Array","lastIndex","_array","set","mergedArray","subarray","lengths","_attributes","lastLengths","createLineGeometry","lines","offset","BufferGeometry","verticesCount","_pickingId","az","c1","addAttribute","BufferAttribute","computeBoundingBox","createGeometry","facesCount","pA","pB","pC","ab","bz","c2","cz","c3","subVectors","cross","nx","ny","nz","textEncoder","TextEncoder","textDecoder","TextDecoder","Stringify","_earcut3","_utilExtrudePolygon","_utilExtrudePolygon2","_enginePickingMaterial2","polygonMaterial","onPolygonMesh","onBufferAttributes","_setCoordinates","addToPicking","_setPickingId","_addPickingEvents","_projectedCoordinates","_bufferAttributes","_outlineBufferAttributes","_flat","_center","_bounds","_convertCoordinates","_projectedBounds","_projectCoordinates","_offset","clearCoordinates","clearBufferAttributes","ToEarcut","Triangulate","_tops","outlineColour","Set2DOutline","ToAttributes","_ring","verticeCount","first","skybox","Material","MeshStandardMaterial","vertexColors","VertexColors","side","BackSide","roughness","metalness","envMapIntensity","envMap","getRenderTarget","MeshPhongMaterial","Mesh","castShadow","receiveShadow","depthWrite","t1","t2","t3","_PickingShader","_PickingShader2","PickingMaterial","ShaderMaterial","uniforms","vertexShader","fragmentShader","linePadding","setPointSize","setPointScale","PickingShader","PolylineLayer","polylineMaterial","onPolylineMesh","lineHeight","LineBasicMaterial","linewidth","LineSegments","polylineLayer","_PolygonLayer","PointLayer","pointMaterial","onPointMesh","pointColor","pointHeight","Geometry","geometryWidth","geometryHeight","_geometry","BoxGeometry","fromGeometry","_normals","normal","pointLayer","_wrapNum","_wrapNum2","_GeoJSON","_GeoJSON2","_Buffer","_Buffer2","_Worker","_Worker2","_Stringify","_Stringify2","wrapNum","range","includeMax"],"mappings":"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","file":"vizicities-worker.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"THREE\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"THREE\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"VIZI\"] = factory(require(\"THREE\"));\n\telse\n\t\troot[\"VIZI\"] = factory(root[\"THREE\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_18__) {\nreturn \n\n\n/** WEBPACK FOOTER **\n ** webpack/universalModuleDefinition\n **/","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"THREE\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"THREE\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"VIZI\"] = factory(require(\"THREE\"));\n\telse\n\t\troot[\"VIZI\"] = factory(root[\"THREE\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_18__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _geoGeoJs = __webpack_require__(1);\n\t\n\tvar _geoGeoJs2 = _interopRequireDefault(_geoGeoJs);\n\t\n\tvar _layerLayer = __webpack_require__(4);\n\t\n\tvar _layerLayer2 = _interopRequireDefault(_layerLayer);\n\t\n\tvar _layerGeoJSONWorkerLayer = __webpack_require__(22);\n\t\n\tvar _layerGeoJSONWorkerLayer2 = _interopRequireDefault(_layerGeoJSONWorkerLayer);\n\t\n\tvar _layerGeometryPolygonLayer = __webpack_require__(36);\n\t\n\tvar _layerGeometryPolygonLayer2 = _interopRequireDefault(_layerGeometryPolygonLayer);\n\t\n\tvar _geoPoint = __webpack_require__(3);\n\t\n\tvar _geoPoint2 = _interopRequireDefault(_geoPoint);\n\t\n\tvar _geoLatLon = __webpack_require__(2);\n\t\n\tvar _geoLatLon2 = _interopRequireDefault(_geoLatLon);\n\t\n\tvar _utilIndex = __webpack_require__(41);\n\t\n\tvar _utilIndex2 = _interopRequireDefault(_utilIndex);\n\t\n\tvar VIZI = {\n\t  version: '0.3',\n\t\n\t  Geo: _geoGeoJs2['default'],\n\t  Layer: _layerLayer2['default'],\n\t  layer: _layerLayer.layer,\n\t  GeoJSONWorkerLayer: _layerGeoJSONWorkerLayer2['default'],\n\t  geoJSONWorkerLayer: _layerGeoJSONWorkerLayer.geoJSONWorkerLayer,\n\t  PolygonLayer: _layerGeometryPolygonLayer2['default'],\n\t  polygonLayer: _layerGeometryPolygonLayer.polygonLayer,\n\t  Point: _geoPoint2['default'],\n\t  point: _geoPoint.point,\n\t  LatLon: _geoLatLon2['default'],\n\t  latLon: _geoLatLon.latLon,\n\t  Util: _utilIndex2['default']\n\t};\n\t\n\texports['default'] = VIZI;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _LatLon = __webpack_require__(2);\n\t\n\tvar _Point = __webpack_require__(3);\n\t\n\tvar Geo = {};\n\t\n\t// Radius / WGS84 semi-major axis\n\tGeo.R = 6378137;\n\tGeo.MAX_LATITUDE = 85.0511287798;\n\t\n\t// WGS84 eccentricity\n\tGeo.ECC = 0.081819191;\n\tGeo.ECC2 = 0.081819191 * 0.081819191;\n\t\n\tGeo.project = function (latlon) {\n\t  var d = Math.PI / 180;\n\t  var max = Geo.MAX_LATITUDE;\n\t  var lat = Math.max(Math.min(max, latlon.lat), -max);\n\t  var sin = Math.sin(lat * d);\n\t\n\t  return (0, _Point.point)(Geo.R * latlon.lon * d, Geo.R * Math.log((1 + sin) / (1 - sin)) / 2);\n\t}, Geo.unproject = function (point) {\n\t  var d = 180 / Math.PI;\n\t\n\t  return (0, _LatLon.latLon)((2 * Math.atan(Math.exp(point.y / Geo.R)) - Math.PI / 2) * d, point.x * d / Geo.R);\n\t};\n\t\n\t// Converts geo coords to pixel / WebGL ones\n\t// This just reverses the Y axis to match WebGL\n\tGeo.latLonToPoint = function (latlon) {\n\t  var projected = Geo.project(latlon);\n\t  projected.y *= -1;\n\t\n\t  return projected;\n\t};\n\t\n\t// Converts pixel / WebGL coords to geo coords\n\t// This just reverses the Y axis to match WebGL\n\tGeo.pointToLatLon = function (point) {\n\t  var _point = (0, _Point.point)(point.x, point.y * -1);\n\t  return Geo.unproject(_point);\n\t};\n\t\n\t// Scale factor for converting between real metres and projected metres\n\t//\n\t// projectedMetres = realMetres * pointScale\n\t// realMetres = projectedMetres / pointScale\n\t//\n\t// Accurate scale factor uses proper Web Mercator scaling\n\t// See pg.9: http://www.hydrometronics.com/downloads/Web%20Mercator%20-%20Non-Conformal,%20Non-Mercator%20(notes).pdf\n\t// See: http://jsfiddle.net/robhawkes/yws924cf/\n\tGeo.pointScale = function (latlon, accurate) {\n\t  var rad = Math.PI / 180;\n\t\n\t  var k;\n\t\n\t  if (!accurate) {\n\t    k = 1 / Math.cos(latlon.lat * rad);\n\t\n\t    // [scaleX, scaleY]\n\t    return [k, k];\n\t  } else {\n\t    var lat = latlon.lat * rad;\n\t    var lon = latlon.lon * rad;\n\t\n\t    var a = Geo.R;\n\t\n\t    var sinLat = Math.sin(lat);\n\t    var sinLat2 = sinLat * sinLat;\n\t\n\t    var cosLat = Math.cos(lat);\n\t\n\t    // Radius meridian\n\t    var p = a * (1 - Geo.ECC2) / Math.pow(1 - Geo.ECC2 * sinLat2, 3 / 2);\n\t\n\t    // Radius prime meridian\n\t    var v = a / Math.sqrt(1 - Geo.ECC2 * sinLat2);\n\t\n\t    // Scale N/S\n\t    var h = a / p / cosLat;\n\t\n\t    // Scale E/W\n\t    k = a / v / cosLat;\n\t\n\t    // [scaleX, scaleY]\n\t    return [k, h];\n\t  }\n\t};\n\t\n\t// Convert real metres to projected units\n\t//\n\t// Latitude scale is chosen because it fluctuates more than longitude\n\tGeo.metresToProjected = function (metres, pointScale) {\n\t  return metres * pointScale[1];\n\t};\n\t\n\t// Convert projected units to real metres\n\t//\n\t// Latitude scale is chosen because it fluctuates more than longitude\n\tGeo.projectedToMetres = function (projectedUnits, pointScale) {\n\t  return projectedUnits / pointScale[1];\n\t};\n\t\n\t// Convert real metres to a value in world (WebGL) units\n\tGeo.metresToWorld = function (metres, pointScale) {\n\t  // Transform metres to projected metres using the latitude point scale\n\t  //\n\t  // Latitude scale is chosen because it fluctuates more than longitude\n\t  var projectedMetres = Geo.metresToProjected(metres, pointScale);\n\t\n\t  var scale = Geo.scale();\n\t\n\t  // Scale projected metres\n\t  var scaledMetres = scale * projectedMetres;\n\t\n\t  return scaledMetres;\n\t};\n\t\n\t// Convert world (WebGL) units to a value in real metres\n\tGeo.worldToMetres = function (worldUnits, pointScale) {\n\t  var scale = Geo.scale();\n\t\n\t  var projectedUnits = worldUnits / scale;\n\t  var realMetres = Geo.projectedToMetres(projectedUnits, pointScale);\n\t\n\t  return realMetres;\n\t};\n\t\n\t// If zoom is provided, returns the map width in pixels for a given zoom\n\t// Else, provides fixed scale value\n\tGeo.scale = function (zoom) {\n\t  // If zoom is provided then return scale based on map tile zoom\n\t  if (zoom >= 0) {\n\t    return 256 * Math.pow(2, zoom);\n\t    // Else, return fixed scale value to expand projected coordinates from\n\t    // their 0 to 1 range into something more practical\n\t  } else {\n\t      return 1;\n\t    }\n\t};\n\t\n\t// Returns zoom level for a given scale value\n\t// This only works with a scale value that is based on map pixel width\n\tGeo.zoom = function (scale) {\n\t  return Math.log(scale / 256) / Math.LN2;\n\t};\n\t\n\t// Distance between two geographical points using spherical law of cosines\n\t// approximation or Haversine\n\t//\n\t// See: http://www.movable-type.co.uk/scripts/latlong.html\n\tGeo.distance = function (latlon1, latlon2, accurate) {\n\t  var rad = Math.PI / 180;\n\t\n\t  var lat1;\n\t  var lat2;\n\t\n\t  var a;\n\t\n\t  if (!accurate) {\n\t    lat1 = latlon1.lat * rad;\n\t    lat2 = latlon2.lat * rad;\n\t\n\t    a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((latlon2.lon - latlon1.lon) * rad);\n\t\n\t    return Geo.R * Math.acos(Math.min(a, 1));\n\t  } else {\n\t    lat1 = latlon1.lat * rad;\n\t    lat2 = latlon2.lat * rad;\n\t\n\t    var lon1 = latlon1.lon * rad;\n\t    var lon2 = latlon2.lon * rad;\n\t\n\t    var deltaLat = lat2 - lat1;\n\t    var deltaLon = lon2 - lon1;\n\t\n\t    var halfDeltaLat = deltaLat / 2;\n\t    var halfDeltaLon = deltaLon / 2;\n\t\n\t    a = Math.sin(halfDeltaLat) * Math.sin(halfDeltaLat) + Math.cos(lat1) * Math.cos(lat2) * Math.sin(halfDeltaLon) * Math.sin(halfDeltaLon);\n\t\n\t    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\t\n\t    return Geo.R * c;\n\t  }\n\t};\n\t\n\tGeo.bounds = (function () {\n\t  var d = Geo.R * Math.PI;\n\t  return [[-d, -d], [d, d]];\n\t})();\n\t\n\texports['default'] = Geo;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 2 */\n/***/ function(module, exports) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\t/*\n\t * LatLon is a helper class for ensuring consistent geographic coordinates.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/LatLng.js\n\t */\n\t\n\tvar LatLon = (function () {\n\t  function LatLon(lat, lon, alt) {\n\t    _classCallCheck(this, LatLon);\n\t\n\t    if (isNaN(lat) || isNaN(lon)) {\n\t      throw new Error('Invalid LatLon object: (' + lat + ', ' + lon + ')');\n\t    }\n\t\n\t    this.lat = +lat;\n\t    this.lon = +lon;\n\t\n\t    if (alt !== undefined) {\n\t      this.alt = +alt;\n\t    }\n\t  }\n\t\n\t  _createClass(LatLon, [{\n\t    key: 'clone',\n\t    value: function clone() {\n\t      return new LatLon(this.lat, this.lon, this.alt);\n\t    }\n\t  }]);\n\t\n\t  return LatLon;\n\t})();\n\t\n\texports['default'] = LatLon;\n\t\n\t// Accepts (LatLon), ([lat, lon, alt]), ([lat, lon]) and (lat, lon, alt)\n\t// Also converts between lng and lon\n\tvar noNew = function noNew(a, b, c) {\n\t  if (a instanceof LatLon) {\n\t    return a;\n\t  }\n\t  if (Array.isArray(a) && typeof a[0] !== 'object') {\n\t    if (a.length === 3) {\n\t      return new LatLon(a[0], a[1], a[2]);\n\t    }\n\t    if (a.length === 2) {\n\t      return new LatLon(a[0], a[1]);\n\t    }\n\t    return null;\n\t  }\n\t  if (a === undefined || a === null) {\n\t    return a;\n\t  }\n\t  if (typeof a === 'object' && 'lat' in a) {\n\t    return new LatLon(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);\n\t  }\n\t  if (b === undefined) {\n\t    return null;\n\t  }\n\t  return new LatLon(a, b, c);\n\t};\n\t\n\t// Initialise without requiring new keyword\n\texports.latLon = noNew;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*\n\t * Point is a helper class for ensuring consistent world positions.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/Point.js\n\t */\n\t\n\tvar Point = (function () {\n\t  function Point(x, y, round) {\n\t    _classCallCheck(this, Point);\n\t\n\t    this.x = round ? Math.round(x) : x;\n\t    this.y = round ? Math.round(y) : y;\n\t  }\n\t\n\t  _createClass(Point, [{\n\t    key: \"clone\",\n\t    value: function clone() {\n\t      return new Point(this.x, this.y);\n\t    }\n\t\n\t    // Non-destructive\n\t  }, {\n\t    key: \"add\",\n\t    value: function add(point) {\n\t      return this.clone()._add(_point(point));\n\t    }\n\t\n\t    // Destructive\n\t  }, {\n\t    key: \"_add\",\n\t    value: function _add(point) {\n\t      this.x += point.x;\n\t      this.y += point.y;\n\t      return this;\n\t    }\n\t\n\t    // Non-destructive\n\t  }, {\n\t    key: \"subtract\",\n\t    value: function subtract(point) {\n\t      return this.clone()._subtract(_point(point));\n\t    }\n\t\n\t    // Destructive\n\t  }, {\n\t    key: \"_subtract\",\n\t    value: function _subtract(point) {\n\t      this.x -= point.x;\n\t      this.y -= point.y;\n\t      return this;\n\t    }\n\t  }]);\n\t\n\t  return Point;\n\t})();\n\t\n\texports[\"default\"] = Point;\n\t\n\t// Accepts (point), ([x, y]) and (x, y, round)\n\tvar _point = function _point(x, y, round) {\n\t  if (x instanceof Point) {\n\t    return x;\n\t  }\n\t  if (Array.isArray(x)) {\n\t    return new Point(x[0], x[1]);\n\t  }\n\t  if (x === undefined || x === null) {\n\t    return x;\n\t  }\n\t  return new Point(x, y, round);\n\t};\n\t\n\t// Initialise without requiring new keyword\n\texports.point = _point;\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tvar _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar _eventemitter3 = __webpack_require__(5);\n\t\n\tvar _eventemitter32 = _interopRequireDefault(_eventemitter3);\n\t\n\tvar _lodashAssign = __webpack_require__(6);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _shortid = __webpack_require__(9);\n\t\n\tvar _shortid2 = _interopRequireDefault(_shortid);\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _engineScene = __webpack_require__(19);\n\t\n\tvar _engineScene2 = _interopRequireDefault(_engineScene);\n\t\n\tvar _vendorCSS3DRenderer = __webpack_require__(20);\n\t\n\tvar _vendorCSS2DRenderer = __webpack_require__(21);\n\t\n\t// TODO: Make sure nothing is left behind in the heap after calling destroy()\n\t\n\t// TODO: Need a single move method that handles moving all the various object\n\t// layers so that the DOM layers stay in sync with the 3D layer\n\t\n\t// TODO: Double check that objects within the _object3D Object3D parent are frustum\n\t// culled even if the layer position stays at the default (0,0,0) and the child\n\t// objects are positioned much further away\n\t//\n\t// Or does the layer being at (0,0,0) prevent the child objects from being\n\t// culled because the layer parent is effectively always in view even if the\n\t// child is actually out of camera\n\t\n\tvar Layer = (function (_EventEmitter) {\n\t  _inherits(Layer, _EventEmitter);\n\t\n\t  function Layer(options) {\n\t    _classCallCheck(this, Layer);\n\t\n\t    _get(Object.getPrototypeOf(Layer.prototype), 'constructor', this).call(this);\n\t\n\t    var defaults = {\n\t      id: _shortid2['default'].generate(),\n\t      output: true,\n\t      outputToScene: true\n\t    };\n\t\n\t    this._options = (0, _lodashAssign2['default'])({}, defaults, options);\n\t\n\t    if (this.isOutput()) {\n\t      this._object3D = new _three2['default'].Object3D();\n\t\n\t      this._dom3D = document.createElement('div');\n\t      this._domObject3D = new _vendorCSS3DRenderer.CSS3DObject(this._dom3D);\n\t\n\t      this._dom2D = document.createElement('div');\n\t      this._domObject2D = new _vendorCSS2DRenderer.CSS2DObject(this._dom2D);\n\t    }\n\t  }\n\t\n\t  // Add THREE object directly to layer\n\t\n\t  _createClass(Layer, [{\n\t    key: 'add',\n\t    value: function add(object) {\n\t      this._object3D.add(object);\n\t    }\n\t\n\t    // Remove THREE object from to layer\n\t  }, {\n\t    key: 'remove',\n\t    value: function remove(object) {\n\t      this._object3D.remove(object);\n\t    }\n\t  }, {\n\t    key: 'addDOM3D',\n\t    value: function addDOM3D(object) {\n\t      this._domObject3D.add(object);\n\t    }\n\t  }, {\n\t    key: 'removeDOM3D',\n\t    value: function removeDOM3D(object) {\n\t      this._domObject3D.remove(object);\n\t    }\n\t  }, {\n\t    key: 'addDOM2D',\n\t    value: function addDOM2D(object) {\n\t      this._domObject2D.add(object);\n\t    }\n\t  }, {\n\t    key: 'removeDOM2D',\n\t    value: function removeDOM2D(object) {\n\t      this._domObject2D.remove(object);\n\t    }\n\t\n\t    // Add layer to world instance and store world reference\n\t  }, {\n\t    key: 'addTo',\n\t    value: function addTo(world) {\n\t      return world.addLayer(this);\n\t    }\n\t\n\t    // Internal method called by World.addLayer to actually add the layer\n\t  }, {\n\t    key: '_addToWorld',\n\t    value: function _addToWorld(world) {\n\t      var _this = this;\n\t\n\t      this._world = world;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        _this._onAdd(world).then(function () {\n\t          _this.emit('added');\n\t          resolve(_this);\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t\n\t    // Must return a promise\n\t  }, {\n\t    key: '_onAdd',\n\t    value: function _onAdd(world) {\n\t      return Promise.resolve(this);\n\t    }\n\t  }, {\n\t    key: 'getPickingId',\n\t    value: function getPickingId() {\n\t      if (this._world._engine._picking) {\n\t        return this._world._engine._picking.getNextId();\n\t      }\n\t\n\t      return false;\n\t    }\n\t\n\t    // TODO: Tidy this up and don't access so many private properties to work\n\t  }, {\n\t    key: 'addToPicking',\n\t    value: function addToPicking(object) {\n\t      if (!this._world._engine._picking) {\n\t        return;\n\t      }\n\t\n\t      this._world._engine._picking.add(object);\n\t    }\n\t  }, {\n\t    key: 'removeFromPicking',\n\t    value: function removeFromPicking(object) {\n\t      if (!this._world._engine._picking) {\n\t        return;\n\t      }\n\t\n\t      this._world._engine._picking.remove(object);\n\t    }\n\t  }, {\n\t    key: 'isOutput',\n\t    value: function isOutput() {\n\t      return this._options.output;\n\t    }\n\t  }, {\n\t    key: 'isOutputToScene',\n\t    value: function isOutputToScene() {\n\t      return this._options.outputToScene;\n\t    }\n\t\n\t    // TODO: Also hide any attached DOM layers\n\t  }, {\n\t    key: 'hide',\n\t    value: function hide() {\n\t      this._object3D.visible = false;\n\t\n\t      if (this._pickingMesh) {\n\t        this._pickingMesh.visible = false;\n\t      }\n\t    }\n\t\n\t    // TODO: Also show any attached DOM layers\n\t  }, {\n\t    key: 'show',\n\t    value: function show() {\n\t      this._object3D.visible = true;\n\t\n\t      if (this._pickingMesh) {\n\t        this._pickingMesh.visible = true;\n\t      }\n\t    }\n\t\n\t    // Destroys the layer and removes it from the scene and memory\n\t  }, {\n\t    key: 'destroy',\n\t    value: function destroy() {\n\t      if (this._object3D && this._object3D.children) {\n\t        // Remove everything else in the layer\n\t        var child;\n\t        for (var i = this._object3D.children.length - 1; i >= 0; i--) {\n\t          child = this._object3D.children[i];\n\t\n\t          if (!child) {\n\t            continue;\n\t          }\n\t\n\t          this.remove(child);\n\t\n\t          if (child.geometry) {\n\t            // Dispose of mesh and materials\n\t            child.geometry.dispose();\n\t            child.geometry = null;\n\t          }\n\t\n\t          if (child.material) {\n\t            if (child.material.map) {\n\t              child.material.map.dispose();\n\t              child.material.map = null;\n\t            }\n\t\n\t            child.material.dispose();\n\t            child.material = null;\n\t          }\n\t        }\n\t      }\n\t\n\t      if (this._domObject3D && this._domObject3D.children) {\n\t        // Remove everything else in the layer\n\t        var child;\n\t        for (var i = this._domObject3D.children.length - 1; i >= 0; i--) {\n\t          child = this._domObject3D.children[i];\n\t\n\t          if (!child) {\n\t            continue;\n\t          }\n\t\n\t          this.removeDOM3D(child);\n\t        }\n\t      }\n\t\n\t      if (this._domObject2D && this._domObject2D.children) {\n\t        // Remove everything else in the layer\n\t        var child;\n\t        for (var i = this._domObject2D.children.length - 1; i >= 0; i--) {\n\t          child = this._domObject2D.children[i];\n\t\n\t          if (!child) {\n\t            continue;\n\t          }\n\t\n\t          this.removeDOM2D(child);\n\t        }\n\t      }\n\t\n\t      this._domObject3D = null;\n\t      this._domObject2D = null;\n\t\n\t      this._world = null;\n\t      this._object3D = null;\n\t    }\n\t  }]);\n\t\n\t  return Layer;\n\t})(_eventemitter32['default']);\n\t\n\texports['default'] = Layer;\n\t\n\tvar noNew = function noNew(options) {\n\t  return new Layer(options);\n\t};\n\t\n\texports.layer = noNew;\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar has = Object.prototype.hasOwnProperty;\n\t\n\t//\n\t// We store our EE objects in a plain object whose properties are event names.\n\t// If `Object.create(null)` is not supported we prefix the event names with a\n\t// `~` to make sure that the built-in object properties are not overridden or\n\t// used as an attack vector.\n\t// We also assume that `Object.create(null)` is available when the event name\n\t// is an ES6 Symbol.\n\t//\n\tvar prefix = typeof Object.create !== 'function' ? '~' : false;\n\t\n\t/**\n\t * Representation of a single EventEmitter function.\n\t *\n\t * @param {Function} fn Event handler to be called.\n\t * @param {Mixed} context Context for function execution.\n\t * @param {Boolean} [once=false] Only emit once\n\t * @api private\n\t */\n\tfunction EE(fn, context, once) {\n\t  this.fn = fn;\n\t  this.context = context;\n\t  this.once = once || false;\n\t}\n\t\n\t/**\n\t * Minimal EventEmitter interface that is molded against the Node.js\n\t * EventEmitter interface.\n\t *\n\t * @constructor\n\t * @api public\n\t */\n\tfunction EventEmitter() { /* Nothing to set */ }\n\t\n\t/**\n\t * Hold the assigned EventEmitters by name.\n\t *\n\t * @type {Object}\n\t * @private\n\t */\n\tEventEmitter.prototype._events = undefined;\n\t\n\t/**\n\t * Return an array listing the events for which the emitter has registered\n\t * listeners.\n\t *\n\t * @returns {Array}\n\t * @api public\n\t */\n\tEventEmitter.prototype.eventNames = function eventNames() {\n\t  var events = this._events\n\t    , names = []\n\t    , name;\n\t\n\t  if (!events) return names;\n\t\n\t  for (name in events) {\n\t    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n\t  }\n\t\n\t  if (Object.getOwnPropertySymbols) {\n\t    return names.concat(Object.getOwnPropertySymbols(events));\n\t  }\n\t\n\t  return names;\n\t};\n\t\n\t/**\n\t * Return a list of assigned event listeners.\n\t *\n\t * @param {String} event The events that should be listed.\n\t * @param {Boolean} exists We only need to know if there are listeners.\n\t * @returns {Array|Boolean}\n\t * @api public\n\t */\n\tEventEmitter.prototype.listeners = function listeners(event, exists) {\n\t  var evt = prefix ? prefix + event : event\n\t    , available = this._events && this._events[evt];\n\t\n\t  if (exists) return !!available;\n\t  if (!available) return [];\n\t  if (available.fn) return [available.fn];\n\t\n\t  for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {\n\t    ee[i] = available[i].fn;\n\t  }\n\t\n\t  return ee;\n\t};\n\t\n\t/**\n\t * Emit an event to all registered event listeners.\n\t *\n\t * @param {String} event The name of the event.\n\t * @returns {Boolean} Indication if we've emitted an event.\n\t * @api public\n\t */\n\tEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n\t  var evt = prefix ? prefix + event : event;\n\t\n\t  if (!this._events || !this._events[evt]) return false;\n\t\n\t  var listeners = this._events[evt]\n\t    , len = arguments.length\n\t    , args\n\t    , i;\n\t\n\t  if ('function' === typeof listeners.fn) {\n\t    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\t\n\t    switch (len) {\n\t      case 1: return listeners.fn.call(listeners.context), true;\n\t      case 2: return listeners.fn.call(listeners.context, a1), true;\n\t      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n\t      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n\t      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n\t      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n\t    }\n\t\n\t    for (i = 1, args = new Array(len -1); i < len; i++) {\n\t      args[i - 1] = arguments[i];\n\t    }\n\t\n\t    listeners.fn.apply(listeners.context, args);\n\t  } else {\n\t    var length = listeners.length\n\t      , j;\n\t\n\t    for (i = 0; i < length; i++) {\n\t      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\t\n\t      switch (len) {\n\t        case 1: listeners[i].fn.call(listeners[i].context); break;\n\t        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n\t        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n\t        default:\n\t          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n\t            args[j - 1] = arguments[j];\n\t          }\n\t\n\t          listeners[i].fn.apply(listeners[i].context, args);\n\t      }\n\t    }\n\t  }\n\t\n\t  return true;\n\t};\n\t\n\t/**\n\t * Register a new EventListener for the given event.\n\t *\n\t * @param {String} event Name of the event.\n\t * @param {Function} fn Callback function.\n\t * @param {Mixed} [context=this] The context of the function.\n\t * @api public\n\t */\n\tEventEmitter.prototype.on = function on(event, fn, context) {\n\t  var listener = new EE(fn, context || this)\n\t    , evt = prefix ? prefix + event : event;\n\t\n\t  if (!this._events) this._events = prefix ? {} : Object.create(null);\n\t  if (!this._events[evt]) this._events[evt] = listener;\n\t  else {\n\t    if (!this._events[evt].fn) this._events[evt].push(listener);\n\t    else this._events[evt] = [\n\t      this._events[evt], listener\n\t    ];\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Add an EventListener that's only called once.\n\t *\n\t * @param {String} event Name of the event.\n\t * @param {Function} fn Callback function.\n\t * @param {Mixed} [context=this] The context of the function.\n\t * @api public\n\t */\n\tEventEmitter.prototype.once = function once(event, fn, context) {\n\t  var listener = new EE(fn, context || this, true)\n\t    , evt = prefix ? prefix + event : event;\n\t\n\t  if (!this._events) this._events = prefix ? {} : Object.create(null);\n\t  if (!this._events[evt]) this._events[evt] = listener;\n\t  else {\n\t    if (!this._events[evt].fn) this._events[evt].push(listener);\n\t    else this._events[evt] = [\n\t      this._events[evt], listener\n\t    ];\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Remove event listeners.\n\t *\n\t * @param {String} event The event we want to remove.\n\t * @param {Function} fn The listener that we need to find.\n\t * @param {Mixed} context Only remove listeners matching this context.\n\t * @param {Boolean} once Only remove once listeners.\n\t * @api public\n\t */\n\tEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n\t  var evt = prefix ? prefix + event : event;\n\t\n\t  if (!this._events || !this._events[evt]) return this;\n\t\n\t  var listeners = this._events[evt]\n\t    , events = [];\n\t\n\t  if (fn) {\n\t    if (listeners.fn) {\n\t      if (\n\t           listeners.fn !== fn\n\t        || (once && !listeners.once)\n\t        || (context && listeners.context !== context)\n\t      ) {\n\t        events.push(listeners);\n\t      }\n\t    } else {\n\t      for (var i = 0, length = listeners.length; i < length; i++) {\n\t        if (\n\t             listeners[i].fn !== fn\n\t          || (once && !listeners[i].once)\n\t          || (context && listeners[i].context !== context)\n\t        ) {\n\t          events.push(listeners[i]);\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  //\n\t  // Reset the array, or remove it completely if we have no more listeners.\n\t  //\n\t  if (events.length) {\n\t    this._events[evt] = events.length === 1 ? events[0] : events;\n\t  } else {\n\t    delete this._events[evt];\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\t/**\n\t * Remove all listeners or only the listeners for the specified event.\n\t *\n\t * @param {String} event The event want to remove all listeners for.\n\t * @api public\n\t */\n\tEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n\t  if (!this._events) return this;\n\t\n\t  if (event) delete this._events[prefix ? prefix + event : event];\n\t  else this._events = prefix ? {} : Object.create(null);\n\t\n\t  return this;\n\t};\n\t\n\t//\n\t// Alias methods names because people roll like that.\n\t//\n\tEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\tEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\t\n\t//\n\t// This function doesn't apply anymore.\n\t//\n\tEventEmitter.prototype.setMaxListeners = function setMaxListeners() {\n\t  return this;\n\t};\n\t\n\t//\n\t// Expose the prefix.\n\t//\n\tEventEmitter.prefixed = prefix;\n\t\n\t//\n\t// Expose the module.\n\t//\n\tif (true) {\n\t  module.exports = EventEmitter;\n\t}\n\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * lodash (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n\t * Released under MIT license <https://lodash.com/license>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t */\n\tvar keys = __webpack_require__(7),\n\t    rest = __webpack_require__(8);\n\t\n\t/** Used as references for various `Number` constants. */\n\tvar MAX_SAFE_INTEGER = 9007199254740991;\n\t\n\t/** `Object#toString` result references. */\n\tvar funcTag = '[object Function]',\n\t    genTag = '[object GeneratorFunction]';\n\t\n\t/** Used to detect unsigned integer values. */\n\tvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\t\n\t/** Used for built-in method references. */\n\tvar objectProto = Object.prototype;\n\t\n\t/** Used to check objects for own properties. */\n\tvar hasOwnProperty = objectProto.hasOwnProperty;\n\t\n\t/**\n\t * Used to resolve the\n\t * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n\t * of values.\n\t */\n\tvar objectToString = objectProto.toString;\n\t\n\t/** Built-in value references. */\n\tvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\t\n\t/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */\n\tvar nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');\n\t\n\t/**\n\t * Assigns `value` to `key` of `object` if the existing value is not equivalent\n\t * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n\t * for equality comparisons.\n\t *\n\t * @private\n\t * @param {Object} object The object to modify.\n\t * @param {string} key The key of the property to assign.\n\t * @param {*} value The value to assign.\n\t */\n\tfunction assignValue(object, key, value) {\n\t  var objValue = object[key];\n\t  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n\t      (value === undefined && !(key in object))) {\n\t    object[key] = value;\n\t  }\n\t}\n\t\n\t/**\n\t * The base implementation of `_.property` without support for deep paths.\n\t *\n\t * @private\n\t * @param {string} key The key of the property to get.\n\t * @returns {Function} Returns the new accessor function.\n\t */\n\tfunction baseProperty(key) {\n\t  return function(object) {\n\t    return object == null ? undefined : object[key];\n\t  };\n\t}\n\t\n\t/**\n\t * Copies properties of `source` to `object`.\n\t *\n\t * @private\n\t * @param {Object} source The object to copy properties from.\n\t * @param {Array} props The property identifiers to copy.\n\t * @param {Object} [object={}] The object to copy properties to.\n\t * @param {Function} [customizer] The function to customize copied values.\n\t * @returns {Object} Returns `object`.\n\t */\n\tfunction copyObject(source, props, object, customizer) {\n\t  object || (object = {});\n\t\n\t  var index = -1,\n\t      length = props.length;\n\t\n\t  while (++index < length) {\n\t    var key = props[index];\n\t\n\t    var newValue = customizer\n\t      ? customizer(object[key], source[key], key, object, source)\n\t      : source[key];\n\t\n\t    assignValue(object, key, newValue);\n\t  }\n\t  return object;\n\t}\n\t\n\t/**\n\t * Creates a function like `_.assign`.\n\t *\n\t * @private\n\t * @param {Function} assigner The function to assign values.\n\t * @returns {Function} Returns the new assigner function.\n\t */\n\tfunction createAssigner(assigner) {\n\t  return rest(function(object, sources) {\n\t    var index = -1,\n\t        length = sources.length,\n\t        customizer = length > 1 ? sources[length - 1] : undefined,\n\t        guard = length > 2 ? sources[2] : undefined;\n\t\n\t    customizer = (assigner.length > 3 && typeof customizer == 'function')\n\t      ? (length--, customizer)\n\t      : undefined;\n\t\n\t    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n\t      customizer = length < 3 ? undefined : customizer;\n\t      length = 1;\n\t    }\n\t    object = Object(object);\n\t    while (++index < length) {\n\t      var source = sources[index];\n\t      if (source) {\n\t        assigner(object, source, index, customizer);\n\t      }\n\t    }\n\t    return object;\n\t  });\n\t}\n\t\n\t/**\n\t * Gets the \"length\" property value of `object`.\n\t *\n\t * **Note:** This function is used to avoid a\n\t * [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) that affects\n\t * Safari on at least iOS 8.1-8.3 ARM64.\n\t *\n\t * @private\n\t * @param {Object} object The object to query.\n\t * @returns {*} Returns the \"length\" value.\n\t */\n\tvar getLength = baseProperty('length');\n\t\n\t/**\n\t * Checks if `value` is a valid array-like index.\n\t *\n\t * @private\n\t * @param {*} value The value to check.\n\t * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n\t * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n\t */\n\tfunction isIndex(value, length) {\n\t  length = length == null ? MAX_SAFE_INTEGER : length;\n\t  return !!length &&\n\t    (typeof value == 'number' || reIsUint.test(value)) &&\n\t    (value > -1 && value % 1 == 0 && value < length);\n\t}\n\t\n\t/**\n\t * Checks if the given arguments are from an iteratee call.\n\t *\n\t * @private\n\t * @param {*} value The potential iteratee value argument.\n\t * @param {*} index The potential iteratee index or key argument.\n\t * @param {*} object The potential iteratee object argument.\n\t * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n\t *  else `false`.\n\t */\n\tfunction isIterateeCall(value, index, object) {\n\t  if (!isObject(object)) {\n\t    return false;\n\t  }\n\t  var type = typeof index;\n\t  if (type == 'number'\n\t        ? (isArrayLike(object) && isIndex(index, object.length))\n\t        : (type == 'string' && index in object)\n\t      ) {\n\t    return eq(object[index], value);\n\t  }\n\t  return false;\n\t}\n\t\n\t/**\n\t * Checks if `value` is likely a prototype object.\n\t *\n\t * @private\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n\t */\n\tfunction isPrototype(value) {\n\t  var Ctor = value && value.constructor,\n\t      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\t\n\t  return value === proto;\n\t}\n\t\n\t/**\n\t * Performs a\n\t * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n\t * comparison between two values to determine if they are equivalent.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to compare.\n\t * @param {*} other The other value to compare.\n\t * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n\t * @example\n\t *\n\t * var object = { 'user': 'fred' };\n\t * var other = { 'user': 'fred' };\n\t *\n\t * _.eq(object, object);\n\t * // => true\n\t *\n\t * _.eq(object, other);\n\t * // => false\n\t *\n\t * _.eq('a', 'a');\n\t * // => true\n\t *\n\t * _.eq('a', Object('a'));\n\t * // => false\n\t *\n\t * _.eq(NaN, NaN);\n\t * // => true\n\t */\n\tfunction eq(value, other) {\n\t  return value === other || (value !== value && other !== other);\n\t}\n\t\n\t/**\n\t * Checks if `value` is array-like. A value is considered array-like if it's\n\t * not a function and has a `value.length` that's an integer greater than or\n\t * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n\t * @example\n\t *\n\t * _.isArrayLike([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArrayLike(document.body.children);\n\t * // => true\n\t *\n\t * _.isArrayLike('abc');\n\t * // => true\n\t *\n\t * _.isArrayLike(_.noop);\n\t * // => false\n\t */\n\tfunction isArrayLike(value) {\n\t  return value != null && isLength(getLength(value)) && !isFunction(value);\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as a `Function` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isFunction(_);\n\t * // => true\n\t *\n\t * _.isFunction(/abc/);\n\t * // => false\n\t */\n\tfunction isFunction(value) {\n\t  // The use of `Object#toString` avoids issues with the `typeof` operator\n\t  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n\t  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n\t  var tag = isObject(value) ? objectToString.call(value) : '';\n\t  return tag == funcTag || tag == genTag;\n\t}\n\t\n\t/**\n\t * Checks if `value` is a valid array-like length.\n\t *\n\t * **Note:** This function is loosely based on\n\t * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a valid length,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isLength(3);\n\t * // => true\n\t *\n\t * _.isLength(Number.MIN_VALUE);\n\t * // => false\n\t *\n\t * _.isLength(Infinity);\n\t * // => false\n\t *\n\t * _.isLength('3');\n\t * // => false\n\t */\n\tfunction isLength(value) {\n\t  return typeof value == 'number' &&\n\t    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n\t}\n\t\n\t/**\n\t * Checks if `value` is the\n\t * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n\t * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n\t * @example\n\t *\n\t * _.isObject({});\n\t * // => true\n\t *\n\t * _.isObject([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObject(_.noop);\n\t * // => true\n\t *\n\t * _.isObject(null);\n\t * // => false\n\t */\n\tfunction isObject(value) {\n\t  var type = typeof value;\n\t  return !!value && (type == 'object' || type == 'function');\n\t}\n\t\n\t/**\n\t * Assigns own enumerable string keyed properties of source objects to the\n\t * destination object. Source objects are applied from left to right.\n\t * Subsequent sources overwrite property assignments of previous sources.\n\t *\n\t * **Note:** This method mutates `object` and is loosely based on\n\t * [`Object.assign`](https://mdn.io/Object/assign).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.10.0\n\t * @category Object\n\t * @param {Object} object The destination object.\n\t * @param {...Object} [sources] The source objects.\n\t * @returns {Object} Returns `object`.\n\t * @see _.assignIn\n\t * @example\n\t *\n\t * function Foo() {\n\t *   this.c = 3;\n\t * }\n\t *\n\t * function Bar() {\n\t *   this.e = 5;\n\t * }\n\t *\n\t * Foo.prototype.d = 4;\n\t * Bar.prototype.f = 6;\n\t *\n\t * _.assign({ 'a': 1 }, new Foo, new Bar);\n\t * // => { 'a': 1, 'c': 3, 'e': 5 }\n\t */\n\tvar assign = createAssigner(function(object, source) {\n\t  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {\n\t    copyObject(source, keys(source), object);\n\t    return;\n\t  }\n\t  for (var key in source) {\n\t    if (hasOwnProperty.call(source, key)) {\n\t      assignValue(object, key, source[key]);\n\t    }\n\t  }\n\t});\n\t\n\tmodule.exports = assign;\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports) {\n\n\t/**\n\t * lodash (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n\t * Released under MIT license <https://lodash.com/license>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t */\n\t\n\t/** Used as references for various `Number` constants. */\n\tvar MAX_SAFE_INTEGER = 9007199254740991;\n\t\n\t/** `Object#toString` result references. */\n\tvar argsTag = '[object Arguments]',\n\t    funcTag = '[object Function]',\n\t    genTag = '[object GeneratorFunction]',\n\t    stringTag = '[object String]';\n\t\n\t/** Used to detect unsigned integer values. */\n\tvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\t\n\t/**\n\t * The base implementation of `_.times` without support for iteratee shorthands\n\t * or max array length checks.\n\t *\n\t * @private\n\t * @param {number} n The number of times to invoke `iteratee`.\n\t * @param {Function} iteratee The function invoked per iteration.\n\t * @returns {Array} Returns the array of results.\n\t */\n\tfunction baseTimes(n, iteratee) {\n\t  var index = -1,\n\t      result = Array(n);\n\t\n\t  while (++index < n) {\n\t    result[index] = iteratee(index);\n\t  }\n\t  return result;\n\t}\n\t\n\t/** Used for built-in method references. */\n\tvar objectProto = Object.prototype;\n\t\n\t/** Used to check objects for own properties. */\n\tvar hasOwnProperty = objectProto.hasOwnProperty;\n\t\n\t/**\n\t * Used to resolve the\n\t * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n\t * of values.\n\t */\n\tvar objectToString = objectProto.toString;\n\t\n\t/** Built-in value references. */\n\tvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\t\n\t/* Built-in method references for those with the same name as other `lodash` methods. */\n\tvar nativeGetPrototype = Object.getPrototypeOf,\n\t    nativeKeys = Object.keys;\n\t\n\t/**\n\t * The base implementation of `_.has` without support for deep paths.\n\t *\n\t * @private\n\t * @param {Object} object The object to query.\n\t * @param {Array|string} key The key to check.\n\t * @returns {boolean} Returns `true` if `key` exists, else `false`.\n\t */\n\tfunction baseHas(object, key) {\n\t  // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`,\n\t  // that are composed entirely of index properties, return `false` for\n\t  // `hasOwnProperty` checks of them.\n\t  return hasOwnProperty.call(object, key) ||\n\t    (typeof object == 'object' && key in object && getPrototype(object) === null);\n\t}\n\t\n\t/**\n\t * The base implementation of `_.keys` which doesn't skip the constructor\n\t * property of prototypes or treat sparse arrays as dense.\n\t *\n\t * @private\n\t * @param {Object} object The object to query.\n\t * @returns {Array} Returns the array of property names.\n\t */\n\tfunction baseKeys(object) {\n\t  return nativeKeys(Object(object));\n\t}\n\t\n\t/**\n\t * The base implementation of `_.property` without support for deep paths.\n\t *\n\t * @private\n\t * @param {string} key The key of the property to get.\n\t * @returns {Function} Returns the new accessor function.\n\t */\n\tfunction baseProperty(key) {\n\t  return function(object) {\n\t    return object == null ? undefined : object[key];\n\t  };\n\t}\n\t\n\t/**\n\t * Gets the \"length\" property value of `object`.\n\t *\n\t * **Note:** This function is used to avoid a\n\t * [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) that affects\n\t * Safari on at least iOS 8.1-8.3 ARM64.\n\t *\n\t * @private\n\t * @param {Object} object The object to query.\n\t * @returns {*} Returns the \"length\" value.\n\t */\n\tvar getLength = baseProperty('length');\n\t\n\t/**\n\t * Gets the `[[Prototype]]` of `value`.\n\t *\n\t * @private\n\t * @param {*} value The value to query.\n\t * @returns {null|Object} Returns the `[[Prototype]]`.\n\t */\n\tfunction getPrototype(value) {\n\t  return nativeGetPrototype(Object(value));\n\t}\n\t\n\t/**\n\t * Creates an array of index keys for `object` values of arrays,\n\t * `arguments` objects, and strings, otherwise `null` is returned.\n\t *\n\t * @private\n\t * @param {Object} object The object to query.\n\t * @returns {Array|null} Returns index keys, else `null`.\n\t */\n\tfunction indexKeys(object) {\n\t  var length = object ? object.length : undefined;\n\t  if (isLength(length) &&\n\t      (isArray(object) || isString(object) || isArguments(object))) {\n\t    return baseTimes(length, String);\n\t  }\n\t  return null;\n\t}\n\t\n\t/**\n\t * Checks if `value` is a valid array-like index.\n\t *\n\t * @private\n\t * @param {*} value The value to check.\n\t * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n\t * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n\t */\n\tfunction isIndex(value, length) {\n\t  length = length == null ? MAX_SAFE_INTEGER : length;\n\t  return !!length &&\n\t    (typeof value == 'number' || reIsUint.test(value)) &&\n\t    (value > -1 && value % 1 == 0 && value < length);\n\t}\n\t\n\t/**\n\t * Checks if `value` is likely a prototype object.\n\t *\n\t * @private\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n\t */\n\tfunction isPrototype(value) {\n\t  var Ctor = value && value.constructor,\n\t      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\t\n\t  return value === proto;\n\t}\n\t\n\t/**\n\t * Checks if `value` is likely an `arguments` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isArguments(function() { return arguments; }());\n\t * // => true\n\t *\n\t * _.isArguments([1, 2, 3]);\n\t * // => false\n\t */\n\tfunction isArguments(value) {\n\t  // Safari 8.1 incorrectly makes `arguments.callee` enumerable in strict mode.\n\t  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n\t    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as an `Array` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @type {Function}\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isArray([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArray(document.body.children);\n\t * // => false\n\t *\n\t * _.isArray('abc');\n\t * // => false\n\t *\n\t * _.isArray(_.noop);\n\t * // => false\n\t */\n\tvar isArray = Array.isArray;\n\t\n\t/**\n\t * Checks if `value` is array-like. A value is considered array-like if it's\n\t * not a function and has a `value.length` that's an integer greater than or\n\t * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n\t * @example\n\t *\n\t * _.isArrayLike([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArrayLike(document.body.children);\n\t * // => true\n\t *\n\t * _.isArrayLike('abc');\n\t * // => true\n\t *\n\t * _.isArrayLike(_.noop);\n\t * // => false\n\t */\n\tfunction isArrayLike(value) {\n\t  return value != null && isLength(getLength(value)) && !isFunction(value);\n\t}\n\t\n\t/**\n\t * This method is like `_.isArrayLike` except that it also checks if `value`\n\t * is an object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an array-like object,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isArrayLikeObject([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArrayLikeObject(document.body.children);\n\t * // => true\n\t *\n\t * _.isArrayLikeObject('abc');\n\t * // => false\n\t *\n\t * _.isArrayLikeObject(_.noop);\n\t * // => false\n\t */\n\tfunction isArrayLikeObject(value) {\n\t  return isObjectLike(value) && isArrayLike(value);\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as a `Function` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isFunction(_);\n\t * // => true\n\t *\n\t * _.isFunction(/abc/);\n\t * // => false\n\t */\n\tfunction isFunction(value) {\n\t  // The use of `Object#toString` avoids issues with the `typeof` operator\n\t  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n\t  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n\t  var tag = isObject(value) ? objectToString.call(value) : '';\n\t  return tag == funcTag || tag == genTag;\n\t}\n\t\n\t/**\n\t * Checks if `value` is a valid array-like length.\n\t *\n\t * **Note:** This function is loosely based on\n\t * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a valid length,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isLength(3);\n\t * // => true\n\t *\n\t * _.isLength(Number.MIN_VALUE);\n\t * // => false\n\t *\n\t * _.isLength(Infinity);\n\t * // => false\n\t *\n\t * _.isLength('3');\n\t * // => false\n\t */\n\tfunction isLength(value) {\n\t  return typeof value == 'number' &&\n\t    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n\t}\n\t\n\t/**\n\t * Checks if `value` is the\n\t * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n\t * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n\t * @example\n\t *\n\t * _.isObject({});\n\t * // => true\n\t *\n\t * _.isObject([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObject(_.noop);\n\t * // => true\n\t *\n\t * _.isObject(null);\n\t * // => false\n\t */\n\tfunction isObject(value) {\n\t  var type = typeof value;\n\t  return !!value && (type == 'object' || type == 'function');\n\t}\n\t\n\t/**\n\t * Checks if `value` is object-like. A value is object-like if it's not `null`\n\t * and has a `typeof` result of \"object\".\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n\t * @example\n\t *\n\t * _.isObjectLike({});\n\t * // => true\n\t *\n\t * _.isObjectLike([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObjectLike(_.noop);\n\t * // => false\n\t *\n\t * _.isObjectLike(null);\n\t * // => false\n\t */\n\tfunction isObjectLike(value) {\n\t  return !!value && typeof value == 'object';\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as a `String` primitive or object.\n\t *\n\t * @static\n\t * @since 0.1.0\n\t * @memberOf _\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isString('abc');\n\t * // => true\n\t *\n\t * _.isString(1);\n\t * // => false\n\t */\n\tfunction isString(value) {\n\t  return typeof value == 'string' ||\n\t    (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);\n\t}\n\t\n\t/**\n\t * Creates an array of the own enumerable property names of `object`.\n\t *\n\t * **Note:** Non-object values are coerced to objects. See the\n\t * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)\n\t * for more details.\n\t *\n\t * @static\n\t * @since 0.1.0\n\t * @memberOf _\n\t * @category Object\n\t * @param {Object} object The object to query.\n\t * @returns {Array} Returns the array of property names.\n\t * @example\n\t *\n\t * function Foo() {\n\t *   this.a = 1;\n\t *   this.b = 2;\n\t * }\n\t *\n\t * Foo.prototype.c = 3;\n\t *\n\t * _.keys(new Foo);\n\t * // => ['a', 'b'] (iteration order is not guaranteed)\n\t *\n\t * _.keys('hi');\n\t * // => ['0', '1']\n\t */\n\tfunction keys(object) {\n\t  var isProto = isPrototype(object);\n\t  if (!(isProto || isArrayLike(object))) {\n\t    return baseKeys(object);\n\t  }\n\t  var indexes = indexKeys(object),\n\t      skipIndexes = !!indexes,\n\t      result = indexes || [],\n\t      length = result.length;\n\t\n\t  for (var key in object) {\n\t    if (baseHas(object, key) &&\n\t        !(skipIndexes && (key == 'length' || isIndex(key, length))) &&\n\t        !(isProto && key == 'constructor')) {\n\t      result.push(key);\n\t    }\n\t  }\n\t  return result;\n\t}\n\t\n\tmodule.exports = keys;\n\n\n/***/ },\n/* 8 */\n/***/ function(module, exports) {\n\n\t/**\n\t * lodash (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n\t * Released under MIT license <https://lodash.com/license>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t */\n\t\n\t/** Used as the `TypeError` message for \"Functions\" methods. */\n\tvar FUNC_ERROR_TEXT = 'Expected a function';\n\t\n\t/** Used as references for various `Number` constants. */\n\tvar INFINITY = 1 / 0,\n\t    MAX_INTEGER = 1.7976931348623157e+308,\n\t    NAN = 0 / 0;\n\t\n\t/** `Object#toString` result references. */\n\tvar funcTag = '[object Function]',\n\t    genTag = '[object GeneratorFunction]',\n\t    symbolTag = '[object Symbol]';\n\t\n\t/** Used to match leading and trailing whitespace. */\n\tvar reTrim = /^\\s+|\\s+$/g;\n\t\n\t/** Used to detect bad signed hexadecimal string values. */\n\tvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\t\n\t/** Used to detect binary string values. */\n\tvar reIsBinary = /^0b[01]+$/i;\n\t\n\t/** Used to detect octal string values. */\n\tvar reIsOctal = /^0o[0-7]+$/i;\n\t\n\t/** Built-in method references without a dependency on `root`. */\n\tvar freeParseInt = parseInt;\n\t\n\t/**\n\t * A faster alternative to `Function#apply`, this function invokes `func`\n\t * with the `this` binding of `thisArg` and the arguments of `args`.\n\t *\n\t * @private\n\t * @param {Function} func The function to invoke.\n\t * @param {*} thisArg The `this` binding of `func`.\n\t * @param {Array} args The arguments to invoke `func` with.\n\t * @returns {*} Returns the result of `func`.\n\t */\n\tfunction apply(func, thisArg, args) {\n\t  var length = args.length;\n\t  switch (length) {\n\t    case 0: return func.call(thisArg);\n\t    case 1: return func.call(thisArg, args[0]);\n\t    case 2: return func.call(thisArg, args[0], args[1]);\n\t    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n\t  }\n\t  return func.apply(thisArg, args);\n\t}\n\t\n\t/** Used for built-in method references. */\n\tvar objectProto = Object.prototype;\n\t\n\t/**\n\t * Used to resolve the\n\t * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n\t * of values.\n\t */\n\tvar objectToString = objectProto.toString;\n\t\n\t/* Built-in method references for those with the same name as other `lodash` methods. */\n\tvar nativeMax = Math.max;\n\t\n\t/**\n\t * Creates a function that invokes `func` with the `this` binding of the\n\t * created function and arguments from `start` and beyond provided as\n\t * an array.\n\t *\n\t * **Note:** This method is based on the\n\t * [rest parameter](https://mdn.io/rest_parameters).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Function\n\t * @param {Function} func The function to apply a rest parameter to.\n\t * @param {number} [start=func.length-1] The start position of the rest parameter.\n\t * @returns {Function} Returns the new function.\n\t * @example\n\t *\n\t * var say = _.rest(function(what, names) {\n\t *   return what + ' ' + _.initial(names).join(', ') +\n\t *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n\t * });\n\t *\n\t * say('hello', 'fred', 'barney', 'pebbles');\n\t * // => 'hello fred, barney, & pebbles'\n\t */\n\tfunction rest(func, start) {\n\t  if (typeof func != 'function') {\n\t    throw new TypeError(FUNC_ERROR_TEXT);\n\t  }\n\t  start = nativeMax(start === undefined ? (func.length - 1) : toInteger(start), 0);\n\t  return function() {\n\t    var args = arguments,\n\t        index = -1,\n\t        length = nativeMax(args.length - start, 0),\n\t        array = Array(length);\n\t\n\t    while (++index < length) {\n\t      array[index] = args[start + index];\n\t    }\n\t    switch (start) {\n\t      case 0: return func.call(this, array);\n\t      case 1: return func.call(this, args[0], array);\n\t      case 2: return func.call(this, args[0], args[1], array);\n\t    }\n\t    var otherArgs = Array(start + 1);\n\t    index = -1;\n\t    while (++index < start) {\n\t      otherArgs[index] = args[index];\n\t    }\n\t    otherArgs[start] = array;\n\t    return apply(func, this, otherArgs);\n\t  };\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as a `Function` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isFunction(_);\n\t * // => true\n\t *\n\t * _.isFunction(/abc/);\n\t * // => false\n\t */\n\tfunction isFunction(value) {\n\t  // The use of `Object#toString` avoids issues with the `typeof` operator\n\t  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n\t  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n\t  var tag = isObject(value) ? objectToString.call(value) : '';\n\t  return tag == funcTag || tag == genTag;\n\t}\n\t\n\t/**\n\t * Checks if `value` is the\n\t * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n\t * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n\t * @example\n\t *\n\t * _.isObject({});\n\t * // => true\n\t *\n\t * _.isObject([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObject(_.noop);\n\t * // => true\n\t *\n\t * _.isObject(null);\n\t * // => false\n\t */\n\tfunction isObject(value) {\n\t  var type = typeof value;\n\t  return !!value && (type == 'object' || type == 'function');\n\t}\n\t\n\t/**\n\t * Checks if `value` is object-like. A value is object-like if it's not `null`\n\t * and has a `typeof` result of \"object\".\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n\t * @example\n\t *\n\t * _.isObjectLike({});\n\t * // => true\n\t *\n\t * _.isObjectLike([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObjectLike(_.noop);\n\t * // => false\n\t *\n\t * _.isObjectLike(null);\n\t * // => false\n\t */\n\tfunction isObjectLike(value) {\n\t  return !!value && typeof value == 'object';\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as a `Symbol` primitive or object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isSymbol(Symbol.iterator);\n\t * // => true\n\t *\n\t * _.isSymbol('abc');\n\t * // => false\n\t */\n\tfunction isSymbol(value) {\n\t  return typeof value == 'symbol' ||\n\t    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n\t}\n\t\n\t/**\n\t * Converts `value` to a finite number.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.12.0\n\t * @category Lang\n\t * @param {*} value The value to convert.\n\t * @returns {number} Returns the converted number.\n\t * @example\n\t *\n\t * _.toFinite(3.2);\n\t * // => 3.2\n\t *\n\t * _.toFinite(Number.MIN_VALUE);\n\t * // => 5e-324\n\t *\n\t * _.toFinite(Infinity);\n\t * // => 1.7976931348623157e+308\n\t *\n\t * _.toFinite('3.2');\n\t * // => 3.2\n\t */\n\tfunction toFinite(value) {\n\t  if (!value) {\n\t    return value === 0 ? value : 0;\n\t  }\n\t  value = toNumber(value);\n\t  if (value === INFINITY || value === -INFINITY) {\n\t    var sign = (value < 0 ? -1 : 1);\n\t    return sign * MAX_INTEGER;\n\t  }\n\t  return value === value ? value : 0;\n\t}\n\t\n\t/**\n\t * Converts `value` to an integer.\n\t *\n\t * **Note:** This function is loosely based on\n\t * [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to convert.\n\t * @returns {number} Returns the converted integer.\n\t * @example\n\t *\n\t * _.toInteger(3.2);\n\t * // => 3\n\t *\n\t * _.toInteger(Number.MIN_VALUE);\n\t * // => 0\n\t *\n\t * _.toInteger(Infinity);\n\t * // => 1.7976931348623157e+308\n\t *\n\t * _.toInteger('3.2');\n\t * // => 3\n\t */\n\tfunction toInteger(value) {\n\t  var result = toFinite(value),\n\t      remainder = result % 1;\n\t\n\t  return result === result ? (remainder ? result - remainder : result) : 0;\n\t}\n\t\n\t/**\n\t * Converts `value` to a number.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to process.\n\t * @returns {number} Returns the number.\n\t * @example\n\t *\n\t * _.toNumber(3.2);\n\t * // => 3.2\n\t *\n\t * _.toNumber(Number.MIN_VALUE);\n\t * // => 5e-324\n\t *\n\t * _.toNumber(Infinity);\n\t * // => Infinity\n\t *\n\t * _.toNumber('3.2');\n\t * // => 3.2\n\t */\n\tfunction toNumber(value) {\n\t  if (typeof value == 'number') {\n\t    return value;\n\t  }\n\t  if (isSymbol(value)) {\n\t    return NAN;\n\t  }\n\t  if (isObject(value)) {\n\t    var other = isFunction(value.valueOf) ? value.valueOf() : value;\n\t    value = isObject(other) ? (other + '') : other;\n\t  }\n\t  if (typeof value != 'string') {\n\t    return value === 0 ? value : +value;\n\t  }\n\t  value = value.replace(reTrim, '');\n\t  var isBinary = reIsBinary.test(value);\n\t  return (isBinary || reIsOctal.test(value))\n\t    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n\t    : (reIsBadHex.test(value) ? NAN : +value);\n\t}\n\t\n\tmodule.exports = rest;\n\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tmodule.exports = __webpack_require__(10);\n\n\n/***/ },\n/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar alphabet = __webpack_require__(11);\n\tvar encode = __webpack_require__(13);\n\tvar decode = __webpack_require__(15);\n\tvar isValid = __webpack_require__(16);\n\t\n\t// Ignore all milliseconds before a certain time to reduce the size of the date entropy without sacrificing uniqueness.\n\t// This number should be updated every year or so to keep the generated id short.\n\t// To regenerate `new Date() - 0` and bump the version. Always bump the version!\n\tvar REDUCE_TIME = 1459707606518;\n\t\n\t// don't change unless we change the algos or REDUCE_TIME\n\t// must be an integer and less than 16\n\tvar version = 6;\n\t\n\t// if you are using cluster or multiple servers use this to make each instance\n\t// has a unique value for worker\n\t// Note: I don't know if this is automatically set when using third\n\t// party cluster solutions such as pm2.\n\tvar clusterWorkerId = __webpack_require__(17) || 0;\n\t\n\t// Counter is used when shortid is called multiple times in one second.\n\tvar counter;\n\t\n\t// Remember the last time shortid was called in case counter is needed.\n\tvar previousSeconds;\n\t\n\t/**\n\t * Generate unique id\n\t * Returns string id\n\t */\n\tfunction generate() {\n\t\n\t    var str = '';\n\t\n\t    var seconds = Math.floor((Date.now() - REDUCE_TIME) * 0.001);\n\t\n\t    if (seconds === previousSeconds) {\n\t        counter++;\n\t    } else {\n\t        counter = 0;\n\t        previousSeconds = seconds;\n\t    }\n\t\n\t    str = str + encode(alphabet.lookup, version);\n\t    str = str + encode(alphabet.lookup, clusterWorkerId);\n\t    if (counter > 0) {\n\t        str = str + encode(alphabet.lookup, counter);\n\t    }\n\t    str = str + encode(alphabet.lookup, seconds);\n\t\n\t    return str;\n\t}\n\t\n\t\n\t/**\n\t * Set the seed.\n\t * Highly recommended if you don't want people to try to figure out your id schema.\n\t * exposed as shortid.seed(int)\n\t * @param seed Integer value to seed the random alphabet.  ALWAYS USE THE SAME SEED or you might get overlaps.\n\t */\n\tfunction seed(seedValue) {\n\t    alphabet.seed(seedValue);\n\t    return module.exports;\n\t}\n\t\n\t/**\n\t * Set the cluster worker or machine id\n\t * exposed as shortid.worker(int)\n\t * @param workerId worker must be positive integer.  Number less than 16 is recommended.\n\t * returns shortid module so it can be chained.\n\t */\n\tfunction worker(workerId) {\n\t    clusterWorkerId = workerId;\n\t    return module.exports;\n\t}\n\t\n\t/**\n\t *\n\t * sets new characters to use in the alphabet\n\t * returns the shuffled alphabet\n\t */\n\tfunction characters(newCharacters) {\n\t    if (newCharacters !== undefined) {\n\t        alphabet.characters(newCharacters);\n\t    }\n\t\n\t    return alphabet.shuffled();\n\t}\n\t\n\t\n\t// Export all other functions as properties of the generate function\n\tmodule.exports = generate;\n\tmodule.exports.generate = generate;\n\tmodule.exports.seed = seed;\n\tmodule.exports.worker = worker;\n\tmodule.exports.characters = characters;\n\tmodule.exports.decode = decode;\n\tmodule.exports.isValid = isValid;\n\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar randomFromSeed = __webpack_require__(12);\n\t\n\tvar ORIGINAL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';\n\tvar alphabet;\n\tvar previousSeed;\n\t\n\tvar shuffled;\n\t\n\tfunction reset() {\n\t    shuffled = false;\n\t}\n\t\n\tfunction setCharacters(_alphabet_) {\n\t    if (!_alphabet_) {\n\t        if (alphabet !== ORIGINAL) {\n\t            alphabet = ORIGINAL;\n\t            reset();\n\t        }\n\t        return;\n\t    }\n\t\n\t    if (_alphabet_ === alphabet) {\n\t        return;\n\t    }\n\t\n\t    if (_alphabet_.length !== ORIGINAL.length) {\n\t        throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. You submitted ' + _alphabet_.length + ' characters: ' + _alphabet_);\n\t    }\n\t\n\t    var unique = _alphabet_.split('').filter(function(item, ind, arr){\n\t       return ind !== arr.lastIndexOf(item);\n\t    });\n\t\n\t    if (unique.length) {\n\t        throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. These characters were not unique: ' + unique.join(', '));\n\t    }\n\t\n\t    alphabet = _alphabet_;\n\t    reset();\n\t}\n\t\n\tfunction characters(_alphabet_) {\n\t    setCharacters(_alphabet_);\n\t    return alphabet;\n\t}\n\t\n\tfunction setSeed(seed) {\n\t    randomFromSeed.seed(seed);\n\t    if (previousSeed !== seed) {\n\t        reset();\n\t        previousSeed = seed;\n\t    }\n\t}\n\t\n\tfunction shuffle() {\n\t    if (!alphabet) {\n\t        setCharacters(ORIGINAL);\n\t    }\n\t\n\t    var sourceArray = alphabet.split('');\n\t    var targetArray = [];\n\t    var r = randomFromSeed.nextValue();\n\t    var characterIndex;\n\t\n\t    while (sourceArray.length > 0) {\n\t        r = randomFromSeed.nextValue();\n\t        characterIndex = Math.floor(r * sourceArray.length);\n\t        targetArray.push(sourceArray.splice(characterIndex, 1)[0]);\n\t    }\n\t    return targetArray.join('');\n\t}\n\t\n\tfunction getShuffled() {\n\t    if (shuffled) {\n\t        return shuffled;\n\t    }\n\t    shuffled = shuffle();\n\t    return shuffled;\n\t}\n\t\n\t/**\n\t * lookup shuffled letter\n\t * @param index\n\t * @returns {string}\n\t */\n\tfunction lookup(index) {\n\t    var alphabetShuffled = getShuffled();\n\t    return alphabetShuffled[index];\n\t}\n\t\n\tmodule.exports = {\n\t    characters: characters,\n\t    seed: setSeed,\n\t    lookup: lookup,\n\t    shuffled: getShuffled\n\t};\n\n\n/***/ },\n/* 12 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\t// Found this seed-based random generator somewhere\n\t// Based on The Central Randomizer 1.3 (C) 1997 by Paul Houle (houle@msc.cornell.edu)\n\t\n\tvar seed = 1;\n\t\n\t/**\n\t * return a random number based on a seed\n\t * @param seed\n\t * @returns {number}\n\t */\n\tfunction getNextValue() {\n\t    seed = (seed * 9301 + 49297) % 233280;\n\t    return seed/(233280.0);\n\t}\n\t\n\tfunction setSeed(_seed_) {\n\t    seed = _seed_;\n\t}\n\t\n\tmodule.exports = {\n\t    nextValue: getNextValue,\n\t    seed: setSeed\n\t};\n\n\n/***/ },\n/* 13 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar randomByte = __webpack_require__(14);\n\t\n\tfunction encode(lookup, number) {\n\t    var loopCounter = 0;\n\t    var done;\n\t\n\t    var str = '';\n\t\n\t    while (!done) {\n\t        str = str + lookup( ( (number >> (4 * loopCounter)) & 0x0f ) | randomByte() );\n\t        done = number < (Math.pow(16, loopCounter + 1 ) );\n\t        loopCounter++;\n\t    }\n\t    return str;\n\t}\n\t\n\tmodule.exports = encode;\n\n\n/***/ },\n/* 14 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tvar crypto = typeof window === 'object' && (window.crypto || window.msCrypto); // IE 11 uses window.msCrypto\n\t\n\tfunction randomByte() {\n\t    if (!crypto || !crypto.getRandomValues) {\n\t        return Math.floor(Math.random() * 256) & 0x30;\n\t    }\n\t    var dest = new Uint8Array(1);\n\t    crypto.getRandomValues(dest);\n\t    return dest[0] & 0x30;\n\t}\n\t\n\tmodule.exports = randomByte;\n\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar alphabet = __webpack_require__(11);\n\t\n\t/**\n\t * Decode the id to get the version and worker\n\t * Mainly for debugging and testing.\n\t * @param id - the shortid-generated id.\n\t */\n\tfunction decode(id) {\n\t    var characters = alphabet.shuffled();\n\t    return {\n\t        version: characters.indexOf(id.substr(0, 1)) & 0x0f,\n\t        worker: characters.indexOf(id.substr(1, 1)) & 0x0f\n\t    };\n\t}\n\t\n\tmodule.exports = decode;\n\n\n/***/ },\n/* 16 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar alphabet = __webpack_require__(11);\n\t\n\tfunction isShortId(id) {\n\t    if (!id || typeof id !== 'string' || id.length < 6 ) {\n\t        return false;\n\t    }\n\t\n\t    var characters = alphabet.characters();\n\t    var len = id.length;\n\t    for(var i = 0; i < len;i++) {\n\t        if (characters.indexOf(id[i]) === -1) {\n\t            return false;\n\t        }\n\t    }\n\t    return true;\n\t}\n\t\n\tmodule.exports = isShortId;\n\n\n/***/ },\n/* 17 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tmodule.exports = 0;\n\n\n/***/ },\n/* 18 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_18__;\n\n/***/ },\n/* 19 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t// This can be imported from anywhere and will still reference the same scene,\n\t// though there is a helper reference in Engine.scene\n\t\n\texports['default'] = (function () {\n\t  var scene = new _three2['default'].Scene();\n\t\n\t  // TODO: Re-enable when this works with the skybox\n\t  // scene.fog = new THREE.Fog(0xffffff, 1, 15000);\n\t  return scene;\n\t})();\n\t\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 20 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t\tvalue: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t// jscs:disable\n\t/* eslint-disable */\n\t\n\t/**\n\t * Based on http://www.emagix.net/academic/mscs-project/item/camera-sync-with-css3-and-webgl-threejs\n\t * @author mrdoob / http://mrdoob.com/\n\t */\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar CSS3DObject = function CSS3DObject(element) {\n\t\n\t\t_three2['default'].Object3D.call(this);\n\t\n\t\tthis.element = element;\n\t\tthis.element.style.position = 'absolute';\n\t\n\t\tthis.addEventListener('removed', function (event) {\n\t\n\t\t\tif (this.element.parentNode !== null) {\n\t\n\t\t\t\tthis.element.parentNode.removeChild(this.element);\n\t\t\t}\n\t\t});\n\t};\n\t\n\tCSS3DObject.prototype = Object.create(_three2['default'].Object3D.prototype);\n\tCSS3DObject.prototype.constructor = CSS3DObject;\n\t\n\tvar CSS3DSprite = function CSS3DSprite(element) {\n\t\n\t\tCSS3DObject.call(this, element);\n\t};\n\t\n\tCSS3DSprite.prototype = Object.create(CSS3DObject.prototype);\n\tCSS3DSprite.prototype.constructor = CSS3DSprite;\n\t\n\t//\n\t\n\tvar CSS3DRenderer = function CSS3DRenderer() {\n\t\n\t\tconsole.log('THREE.CSS3DRenderer', _three2['default'].REVISION);\n\t\n\t\tvar _width, _height;\n\t\tvar _widthHalf, _heightHalf;\n\t\n\t\tvar matrix = new _three2['default'].Matrix4();\n\t\n\t\tvar cache = {\n\t\t\tcamera: { fov: 0, style: '' },\n\t\t\tobjects: {}\n\t\t};\n\t\n\t\tvar domElement = document.createElement('div');\n\t\tdomElement.style.overflow = 'hidden';\n\t\n\t\tdomElement.style.WebkitTransformStyle = 'preserve-3d';\n\t\tdomElement.style.MozTransformStyle = 'preserve-3d';\n\t\tdomElement.style.oTransformStyle = 'preserve-3d';\n\t\tdomElement.style.transformStyle = 'preserve-3d';\n\t\n\t\tthis.domElement = domElement;\n\t\n\t\tvar cameraElement = document.createElement('div');\n\t\n\t\tcameraElement.style.WebkitTransformStyle = 'preserve-3d';\n\t\tcameraElement.style.MozTransformStyle = 'preserve-3d';\n\t\tcameraElement.style.oTransformStyle = 'preserve-3d';\n\t\tcameraElement.style.transformStyle = 'preserve-3d';\n\t\n\t\tdomElement.appendChild(cameraElement);\n\t\n\t\tthis.setClearColor = function () {};\n\t\n\t\tthis.getSize = function () {\n\t\n\t\t\treturn {\n\t\t\t\twidth: _width,\n\t\t\t\theight: _height\n\t\t\t};\n\t\t};\n\t\n\t\tthis.setSize = function (width, height) {\n\t\n\t\t\t_width = width;\n\t\t\t_height = height;\n\t\n\t\t\t_widthHalf = _width / 2;\n\t\t\t_heightHalf = _height / 2;\n\t\n\t\t\tdomElement.style.width = width + 'px';\n\t\t\tdomElement.style.height = height + 'px';\n\t\n\t\t\tcameraElement.style.width = width + 'px';\n\t\t\tcameraElement.style.height = height + 'px';\n\t\t};\n\t\n\t\tvar epsilon = function epsilon(value) {\n\t\n\t\t\treturn Math.abs(value) < Number.EPSILON ? 0 : value;\n\t\t};\n\t\n\t\tvar getCameraCSSMatrix = function getCameraCSSMatrix(matrix) {\n\t\n\t\t\tvar elements = matrix.elements;\n\t\n\t\t\treturn 'matrix3d(' + epsilon(elements[0]) + ',' + epsilon(-elements[1]) + ',' + epsilon(elements[2]) + ',' + epsilon(elements[3]) + ',' + epsilon(elements[4]) + ',' + epsilon(-elements[5]) + ',' + epsilon(elements[6]) + ',' + epsilon(elements[7]) + ',' + epsilon(elements[8]) + ',' + epsilon(-elements[9]) + ',' + epsilon(elements[10]) + ',' + epsilon(elements[11]) + ',' + epsilon(elements[12]) + ',' + epsilon(-elements[13]) + ',' + epsilon(elements[14]) + ',' + epsilon(elements[15]) + ')';\n\t\t};\n\t\n\t\tvar getObjectCSSMatrix = function getObjectCSSMatrix(matrix) {\n\t\n\t\t\tvar elements = matrix.elements;\n\t\n\t\t\treturn 'translate3d(-50%,-50%,0) matrix3d(' + epsilon(elements[0]) + ',' + epsilon(elements[1]) + ',' + epsilon(elements[2]) + ',' + epsilon(elements[3]) + ',' + epsilon(-elements[4]) + ',' + epsilon(-elements[5]) + ',' + epsilon(-elements[6]) + ',' + epsilon(-elements[7]) + ',' + epsilon(elements[8]) + ',' + epsilon(elements[9]) + ',' + epsilon(elements[10]) + ',' + epsilon(elements[11]) + ',' + epsilon(elements[12]) + ',' + epsilon(elements[13]) + ',' + epsilon(elements[14]) + ',' + epsilon(elements[15]) + ')';\n\t\t};\n\t\n\t\tvar renderObject = function renderObject(object, camera) {\n\t\n\t\t\tif (object instanceof CSS3DObject) {\n\t\n\t\t\t\tvar style;\n\t\n\t\t\t\tif (object instanceof CSS3DSprite) {\n\t\n\t\t\t\t\t// http://swiftcoder.wordpress.com/2008/11/25/constructing-a-billboard-matrix/\n\t\n\t\t\t\t\tmatrix.copy(camera.matrixWorldInverse);\n\t\t\t\t\tmatrix.transpose();\n\t\t\t\t\tmatrix.copyPosition(object.matrixWorld);\n\t\t\t\t\tmatrix.scale(object.scale);\n\t\n\t\t\t\t\tmatrix.elements[3] = 0;\n\t\t\t\t\tmatrix.elements[7] = 0;\n\t\t\t\t\tmatrix.elements[11] = 0;\n\t\t\t\t\tmatrix.elements[15] = 1;\n\t\n\t\t\t\t\tstyle = getObjectCSSMatrix(matrix);\n\t\t\t\t} else {\n\t\n\t\t\t\t\tstyle = getObjectCSSMatrix(object.matrixWorld);\n\t\t\t\t}\n\t\n\t\t\t\tvar element = object.element;\n\t\t\t\tvar cachedStyle = cache.objects[object.id];\n\t\n\t\t\t\tif (cachedStyle === undefined || cachedStyle !== style) {\n\t\n\t\t\t\t\telement.style.WebkitTransform = style;\n\t\t\t\t\telement.style.MozTransform = style;\n\t\t\t\t\telement.style.oTransform = style;\n\t\t\t\t\telement.style.transform = style;\n\t\n\t\t\t\t\tcache.objects[object.id] = style;\n\t\t\t\t}\n\t\n\t\t\t\tif (element.parentNode !== cameraElement) {\n\t\n\t\t\t\t\tcameraElement.appendChild(element);\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tfor (var i = 0, l = object.children.length; i < l; i++) {\n\t\n\t\t\t\trenderObject(object.children[i], camera);\n\t\t\t}\n\t\t};\n\t\n\t\tthis.render = function (scene, camera) {\n\t\n\t\t\tvar fov = 0.5 / Math.tan(_three2['default'].Math.degToRad(camera.fov * 0.5)) * _height;\n\t\n\t\t\tif (cache.camera.fov !== fov) {\n\t\n\t\t\t\tdomElement.style.WebkitPerspective = fov + 'px';\n\t\t\t\tdomElement.style.MozPerspective = fov + 'px';\n\t\t\t\tdomElement.style.oPerspective = fov + 'px';\n\t\t\t\tdomElement.style.perspective = fov + 'px';\n\t\n\t\t\t\tcache.camera.fov = fov;\n\t\t\t}\n\t\n\t\t\tscene.updateMatrixWorld();\n\t\n\t\t\tif (camera.parent === null) camera.updateMatrixWorld();\n\t\n\t\t\tcamera.matrixWorldInverse.getInverse(camera.matrixWorld);\n\t\n\t\t\tvar style = 'translate3d(0,0,' + fov + 'px)' + getCameraCSSMatrix(camera.matrixWorldInverse) + ' translate3d(' + _widthHalf + 'px,' + _heightHalf + 'px, 0)';\n\t\n\t\t\tif (cache.camera.style !== style) {\n\t\n\t\t\t\tcameraElement.style.WebkitTransform = style;\n\t\t\t\tcameraElement.style.MozTransform = style;\n\t\t\t\tcameraElement.style.oTransform = style;\n\t\t\t\tcameraElement.style.transform = style;\n\t\n\t\t\t\tcache.camera.style = style;\n\t\t\t}\n\t\n\t\t\trenderObject(scene, camera);\n\t\t};\n\t};\n\t\n\texports.CSS3DObject = CSS3DObject;\n\texports.CSS3DSprite = CSS3DSprite;\n\texports.CSS3DRenderer = CSS3DRenderer;\n\t\n\t_three2['default'].CSS3DObject = CSS3DObject;\n\t_three2['default'].CSS3DSprite = CSS3DSprite;\n\t_three2['default'].CSS3DRenderer = CSS3DRenderer;\n\n/***/ },\n/* 21 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t\tvalue: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t// jscs:disable\n\t/* eslint-disable */\n\t\n\t/**\n\t * @author mrdoob / http://mrdoob.com/\n\t */\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar CSS2DObject = function CSS2DObject(element) {\n\t\n\t\t_three2['default'].Object3D.call(this);\n\t\n\t\tthis.element = element;\n\t\tthis.element.style.position = 'absolute';\n\t\n\t\tthis.addEventListener('removed', function (event) {\n\t\n\t\t\tif (this.element.parentNode !== null) {\n\t\n\t\t\t\tthis.element.parentNode.removeChild(this.element);\n\t\t\t}\n\t\t});\n\t};\n\t\n\tCSS2DObject.prototype = Object.create(_three2['default'].Object3D.prototype);\n\tCSS2DObject.prototype.constructor = CSS2DObject;\n\t\n\t//\n\t\n\tvar CSS2DRenderer = function CSS2DRenderer() {\n\t\n\t\tconsole.log('THREE.CSS2DRenderer', _three2['default'].REVISION);\n\t\n\t\tvar _width, _height;\n\t\tvar _widthHalf, _heightHalf;\n\t\n\t\tvar vector = new _three2['default'].Vector3();\n\t\tvar viewMatrix = new _three2['default'].Matrix4();\n\t\tvar viewProjectionMatrix = new _three2['default'].Matrix4();\n\t\n\t\tvar frustum = new _three2['default'].Frustum();\n\t\n\t\tvar domElement = document.createElement('div');\n\t\tdomElement.style.overflow = 'hidden';\n\t\n\t\tthis.domElement = domElement;\n\t\n\t\tthis.setSize = function (width, height) {\n\t\n\t\t\t_width = width;\n\t\t\t_height = height;\n\t\n\t\t\t_widthHalf = _width / 2;\n\t\t\t_heightHalf = _height / 2;\n\t\n\t\t\tdomElement.style.width = width + 'px';\n\t\t\tdomElement.style.height = height + 'px';\n\t\t};\n\t\n\t\tvar renderObject = function renderObject(object, camera) {\n\t\n\t\t\tif (object instanceof CSS2DObject) {\n\t\n\t\t\t\tvector.setFromMatrixPosition(object.matrixWorld);\n\t\t\t\tvector.applyProjection(viewProjectionMatrix);\n\t\n\t\t\t\tvar element = object.element;\n\t\t\t\tvar style = 'translate(-50%,-50%) translate(' + (vector.x * _widthHalf + _widthHalf) + 'px,' + (-vector.y * _heightHalf + _heightHalf) + 'px)';\n\t\n\t\t\t\telement.style.WebkitTransform = style;\n\t\t\t\telement.style.MozTransform = style;\n\t\t\t\telement.style.oTransform = style;\n\t\t\t\telement.style.transform = style;\n\t\n\t\t\t\tif (element.parentNode !== domElement) {\n\t\n\t\t\t\t\tdomElement.appendChild(element);\n\t\t\t\t}\n\t\n\t\t\t\t// Hide if outside view frustum\n\t\t\t\tif (!frustum.containsPoint(object.position)) {\n\t\t\t\t\telement.style.display = 'none';\n\t\t\t\t} else {\n\t\t\t\t\telement.style.display = 'block';\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tfor (var i = 0, l = object.children.length; i < l; i++) {\n\t\n\t\t\t\trenderObject(object.children[i], camera);\n\t\t\t}\n\t\t};\n\t\n\t\tthis.render = function (scene, camera) {\n\t\n\t\t\tscene.updateMatrixWorld();\n\t\n\t\t\tif (camera.parent === null) camera.updateMatrixWorld();\n\t\n\t\t\tcamera.matrixWorldInverse.getInverse(camera.matrixWorld);\n\t\n\t\t\tviewMatrix.copy(camera.matrixWorldInverse.getInverse(camera.matrixWorld));\n\t\t\tviewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, viewMatrix);\n\t\n\t\t\tfrustum.setFromMatrix(new _three2['default'].Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse));\n\t\n\t\t\trenderObject(scene, camera);\n\t\t};\n\t};\n\t\n\texports.CSS2DObject = CSS2DObject;\n\texports.CSS2DRenderer = CSS2DRenderer;\n\t\n\t_three2['default'].CSS2DObject = CSS2DObject;\n\t_three2['default'].CSS2DRenderer = CSS2DRenderer;\n\n/***/ },\n/* 22 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _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'); } }; })();\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tvar _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\tvar _Layer2 = __webpack_require__(4);\n\t\n\tvar _Layer3 = _interopRequireDefault(_Layer2);\n\t\n\tvar _lodashAssign = __webpack_require__(6);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _reqwest = __webpack_require__(23);\n\t\n\tvar _reqwest2 = _interopRequireDefault(_reqwest);\n\t\n\tvar _utilGeoJSON = __webpack_require__(25);\n\t\n\tvar _utilGeoJSON2 = _interopRequireDefault(_utilGeoJSON);\n\t\n\tvar _utilWorker = __webpack_require__(31);\n\t\n\tvar _utilWorker2 = _interopRequireDefault(_utilWorker);\n\t\n\tvar _utilBuffer = __webpack_require__(34);\n\t\n\tvar _utilBuffer2 = _interopRequireDefault(_utilBuffer);\n\t\n\tvar _utilStringify = __webpack_require__(35);\n\t\n\tvar _utilStringify2 = _interopRequireDefault(_utilStringify);\n\t\n\tvar _geometryPolygonLayer = __webpack_require__(36);\n\t\n\tvar _geometryPolygonLayer2 = _interopRequireDefault(_geometryPolygonLayer);\n\t\n\tvar _geometryPolylineLayer = __webpack_require__(39);\n\t\n\tvar _geometryPolylineLayer2 = _interopRequireDefault(_geometryPolylineLayer);\n\t\n\tvar _geometryPointLayer = __webpack_require__(40);\n\t\n\tvar _geometryPointLayer2 = _interopRequireDefault(_geometryPointLayer);\n\t\n\tvar _geoLatLon = __webpack_require__(2);\n\t\n\tvar _geoPoint = __webpack_require__(3);\n\t\n\tvar _geoGeo = __webpack_require__(1);\n\t\n\tvar _geoGeo2 = _interopRequireDefault(_geoGeo);\n\t\n\tvar _enginePickingMaterial = __webpack_require__(37);\n\t\n\tvar _enginePickingMaterial2 = _interopRequireDefault(_enginePickingMaterial);\n\t\n\t// TODO: Allow filter method to be run inside a worker to improve performance\n\t// TODO: Allow onEachFeature method to be run inside a worker to improve performance\n\t\n\tvar GeoJSONWorkerLayer = (function (_Layer) {\n\t  _inherits(GeoJSONWorkerLayer, _Layer);\n\t\n\t  function GeoJSONWorkerLayer(geojson, options) {\n\t    _classCallCheck(this, GeoJSONWorkerLayer);\n\t\n\t    var defaults = {\n\t      topojson: false,\n\t      style: _utilGeoJSON2['default'].defaultStyle,\n\t      onEachFeature: null,\n\t      onEachFeatureWorker: null,\n\t      onAddAttributes: null,\n\t      interactive: false,\n\t      pointGeometry: null,\n\t      onClick: null,\n\t      headers: {}\n\t    };\n\t\n\t    var _options = (0, _lodashAssign2['default'])({}, defaults, options);\n\t\n\t    if (typeof options.style === 'object') {\n\t      _options.style = (0, _lodashAssign2['default'])({}, defaults.style, options.style);\n\t    }\n\t\n\t    _get(Object.getPrototypeOf(GeoJSONWorkerLayer.prototype), 'constructor', this).call(this, _options);\n\t\n\t    this._aborted = false;\n\t    this._geojson = geojson;\n\t  }\n\t\n\t  _createClass(GeoJSONWorkerLayer, [{\n\t    key: '_onAdd',\n\t    value: function _onAdd(world) {\n\t      if (this._options.interactive) {\n\t        // Worker layer always controls output to add a picking mesh\n\t        this._pickingMesh = new THREE.Object3D();\n\t      }\n\t\n\t      // Process GeoJSON\n\t      return this._process(this._geojson);\n\t    }\n\t\n\t    // Use workers to request and process GeoJSON, returning data structure\n\t    // containing geometry and any supplementary data for output\n\t  }, {\n\t    key: '_process',\n\t    value: function _process(_geojson) {\n\t      var _this = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        var style = _this._options.style;\n\t\n\t        // TODO: Convert to buffer and use transferrable objects\n\t        if (typeof _this._options.style === 'function') {\n\t          style = _utilStringify2['default'].functionToString(_this._options.style);\n\t        }\n\t\n\t        var pointGeometry = _this._options.pointGeometry;\n\t\n\t        // TODO: Convert to buffer and use transferrable objects\n\t        if (typeof _this._options.pointGeometry === 'function') {\n\t          pointGeometry = _utilStringify2['default'].functionToString(_this._options.pointGeometry);\n\t        }\n\t\n\t        var geojson = _geojson;\n\t        var transferrables = [];\n\t\n\t        if (typeof geojson !== 'string') {\n\t          _this._geojson = geojson = _utilBuffer2['default'].stringToUint8Array(JSON.stringify(geojson));\n\t          transferrables.push(geojson.buffer);\n\t          _this._execWorker(geojson, _this._options.topojson, _this._world._originPoint, style, _this._options.interactive, pointGeometry, transferrables).then(function () {\n\t            resolve();\n\t          })['catch'](reject);\n\t        } else if (typeof _this._options.filter === 'function' || typeof _this._options.onEachFeature === 'function') {\n\t          GeoJSONWorkerLayer.RequestGeoJSON(geojson).then(function (res) {\n\t            // if (this._aborted) {\n\t            //   resolve();\n\t            //   return;\n\t            // }\n\t\n\t            var fc = _utilGeoJSON2['default'].collectFeatures(res, _this._options.topojson);\n\t            var features = fc.features;\n\t\n\t            // Run filter, if provided\n\t            if (_this._options.filter) {\n\t              fc.features = features.filter(_this._options.filter);\n\t            }\n\t\n\t            if (_this._options.onEachFeature) {\n\t              var feature;\n\t              for (var i = 0; i < features.length; i++) {\n\t                feature = features[i];\n\t                _this._options.onEachFeature(feature);\n\t              };\n\t            }\n\t\n\t            _this._geojson = geojson = _utilBuffer2['default'].stringToUint8Array(JSON.stringify(fc));\n\t            transferrables.push(geojson.buffer);\n\t\n\t            _this._execWorker(geojson, false, _this._options.headers, _this._world._originPoint, style, _this._options.interactive, pointGeometry, transferrables).then(function () {\n\t              resolve();\n\t            })['catch'](reject);\n\t          });\n\t        } else {\n\t          _this._execWorker(geojson, _this._options.topojson, _this._options.headers, _this._world._originPoint, style, _this._options.interactive, pointGeometry, transferrables).then(function () {\n\t            resolve();\n\t          })['catch'](reject);\n\t        }\n\t      });\n\t    }\n\t  }, {\n\t    key: '_execWorker',\n\t    value: function _execWorker(geojson, topojson, headers, originPoint, style, interactive, pointGeometry, transferrables) {\n\t      var _this2 = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        console.time('Worker round trip');\n\t\n\t        _utilWorker2['default'].exec('GeoJSONWorkerLayer.Process', [geojson, topojson, headers, originPoint, style, interactive, pointGeometry], transferrables).then(function (results) {\n\t          console.timeEnd('Worker round trip');\n\t\n\t          // if (this._aborted) {\n\t          //   resolve();\n\t          //   return;\n\t          // }\n\t\n\t          var processPromises = [];\n\t\n\t          if (results.polygons) {\n\t            processPromises.push(_this2._processPolygonResults(results.polygons));\n\t          }\n\t\n\t          if (results.polylines) {\n\t            processPromises.push(_this2._processPolylineResults(results.polylines));\n\t          }\n\t\n\t          if (results.points) {\n\t            processPromises.push(_this2._processPointResults(results.points));\n\t          }\n\t\n\t          if (processPromises.length > 0) {\n\t            Promise.all(processPromises).then(function () {\n\t              resolve();\n\t            })['catch'](reject);\n\t          } else {\n\t            resolve();\n\t          }\n\t        });\n\t      });\n\t    }\n\t\n\t    // TODO: Dedupe with polyline method\n\t  }, {\n\t    key: '_processPolygonResults',\n\t    value: function _processPolygonResults(results) {\n\t      var _this3 = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        var splitPositions = _utilBuffer2['default'].splitFloat32Array(results.attributes.positions);\n\t        var splitNormals = _utilBuffer2['default'].splitFloat32Array(results.attributes.normals);\n\t        var splitColors = _utilBuffer2['default'].splitFloat32Array(results.attributes.colors);\n\t        var splitTops = _utilBuffer2['default'].splitFloat32Array(results.attributes.tops);\n\t\n\t        var splitOutlinePositions;\n\t        var splitOutlineColors;\n\t\n\t        if (results.outlineAttributes) {\n\t          splitOutlinePositions = _utilBuffer2['default'].splitFloat32Array(results.outlineAttributes.positions);\n\t          splitOutlineColors = _utilBuffer2['default'].splitFloat32Array(results.outlineAttributes.colors);\n\t        }\n\t\n\t        var splitProperties;\n\t        if (results.properties) {\n\t          splitProperties = _utilBuffer2['default'].splitUint8Array(results.properties);\n\t        }\n\t\n\t        var flats = results.flats;\n\t\n\t        var objects = [];\n\t        var outlineObjects = [];\n\t\n\t        var obj;\n\t        var pickingId;\n\t        var pickingIds;\n\t        var properties;\n\t\n\t        var polygonAttributeLengths = {\n\t          positions: 3,\n\t          normals: 3,\n\t          colors: 3,\n\t          tops: 1\n\t        };\n\t\n\t        var polygonOutlineAttributeLengths = {\n\t          positions: 3,\n\t          colors: 3\n\t        };\n\t\n\t        for (var i = 0; i < splitPositions.length; i++) {\n\t          if (splitProperties && splitProperties[i]) {\n\t            properties = JSON.parse(_utilBuffer2['default'].uint8ArrayToString(splitProperties[i]));\n\t          } else {\n\t            properties = {};\n\t          }\n\t\n\t          // WORKERS: obj.attributes should actually an array of polygons for\n\t          // the feature, though the current logic isn't aware of that\n\t          obj = {\n\t            attributes: [{\n\t              positions: splitPositions[i],\n\t              normals: splitNormals[i],\n\t              colors: splitColors[i],\n\t              tops: splitTops[i]\n\t            }],\n\t            properties: properties,\n\t            flat: flats[i]\n\t          };\n\t\n\t          // WORKERS: If interactive, generate unique ID for each feature, create\n\t          // the buffer attributes and set up event listeners\n\t          if (_this3._options.interactive) {\n\t            pickingId = _this3.getPickingId();\n\t\n\t            pickingIds = new Float32Array(splitPositions[i].length / 3);\n\t            pickingIds.fill(pickingId);\n\t\n\t            obj.attributes[0].pickingIds = pickingIds;\n\t\n\t            polygonAttributeLengths.pickingIds = 1;\n\t\n\t            _this3._addPicking(pickingId, properties);\n\t          }\n\t\n\t          // TODO: Make this specific to polygon attributes\n\t          if (typeof _this3._options.onAddAttributes === 'function') {\n\t            var customAttributes = _this3._options.onAddAttributes(obj.attributes[0], properties);\n\t            var customAttribute;\n\t            for (var key in customAttributes) {\n\t              customAttribute = customAttributes[key];\n\t              obj.attributes[0][key] = customAttribute.value;\n\t              polygonAttributeLengths[key] = customAttribute.length;\n\t            }\n\t          }\n\t\n\t          objects.push(obj);\n\t        }\n\t\n\t        for (var i = 0; i < splitOutlinePositions.length; i++) {\n\t          obj = {\n\t            attributes: [{\n\t              positions: splitOutlinePositions[i],\n\t              colors: splitOutlineColors[i]\n\t            }],\n\t            flat: true\n\t          };\n\t\n\t          outlineObjects.push(obj);\n\t        }\n\t\n\t        var polygonAttributes = [];\n\t        var polygonOutlineAttributes = [];\n\t\n\t        var polygonFlat = true;\n\t\n\t        for (var i = 0; i < objects.length; i++) {\n\t          obj = objects[i];\n\t\n\t          // TODO: Work out why obj.flat is rarely set to something other than\n\t          // true or false. Potentially undefined.\n\t          if (polygonFlat && obj.flat === false) {\n\t            polygonFlat = false;\n\t          }\n\t\n\t          var bufferAttributes = _utilBuffer2['default'].mergeAttributes(obj.attributes);\n\t          polygonAttributes.push(bufferAttributes);\n\t        };\n\t\n\t        for (var i = 0; i < outlineObjects.length; i++) {\n\t          obj = outlineObjects[i];\n\t\n\t          var bufferAttributes = _utilBuffer2['default'].mergeAttributes(obj.attributes);\n\t          polygonOutlineAttributes.push(bufferAttributes);\n\t        };\n\t\n\t        var outputPromises = [];\n\t\n\t        var style;\n\t\n\t        if (polygonAttributes.length > 0) {\n\t          var mergedPolygonAttributes = _utilBuffer2['default'].mergeAttributes(polygonAttributes);\n\t\n\t          // TODO: Make this work when style is a function per feature\n\t          style = typeof _this3._options.style === 'function' ? _this3._options.style(objects[0]) : _this3._options.style;\n\t          style = (0, _lodashAssign2['default'])({}, _utilGeoJSON2['default'].defaultStyle, style);\n\t\n\t          outputPromises.push(_this3._setPolygonMesh(mergedPolygonAttributes, polygonAttributeLengths, style, polygonFlat));\n\t        }\n\t\n\t        if (polygonOutlineAttributes.length > 0) {\n\t          var mergedPolygonOutlineAttributes = _utilBuffer2['default'].mergeAttributes(polygonOutlineAttributes);\n\t\n\t          style = typeof _this3._options.style === 'function' ? _this3._options.style(objects[0]) : _this3._options.style;\n\t          style = (0, _lodashAssign2['default'])({}, _utilGeoJSON2['default'].defaultStyle, style);\n\t\n\t          if (style.outlineRenderOrder !== undefined) {\n\t            style.lineRenderOrder = style.outlineRenderOrder;\n\t          } else {\n\t            style.lineRenderOrder = style.renderOrder ? style.renderOrder + 1 : 4;\n\t          }\n\t\n\t          if (style.outlineWidth) {\n\t            style.lineWidth = style.outlineWidth;\n\t          }\n\t\n\t          outputPromises.push(_this3._setPolylineMesh(mergedPolygonOutlineAttributes, polygonOutlineAttributeLengths, style, true));\n\t        }\n\t\n\t        Promise.all(outputPromises).then(function (results) {\n\t          var _results = _slicedToArray(results, 2);\n\t\n\t          var polygonResult = _results[0];\n\t          var outlineResult = _results[1];\n\t\n\t          if (polygonResult) {\n\t            _this3._polygonMesh = polygonResult.mesh;\n\t            _this3.add(_this3._polygonMesh);\n\t\n\t            if (polygonResult.pickingMesh) {\n\t              _this3._pickingMesh.add(polygonResult.pickingMesh);\n\t            }\n\t          }\n\t\n\t          if (outlineResult) {\n\t            _this3.add(outlineResult.mesh);\n\t          }\n\t\n\t          resolve();\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t\n\t    // TODO: Dedupe with polygon method\n\t  }, {\n\t    key: '_processPolylineResults',\n\t    value: function _processPolylineResults(results) {\n\t      var _this4 = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        var splitPositions = _utilBuffer2['default'].splitFloat32Array(results.attributes.positions);\n\t        var splitColors = _utilBuffer2['default'].splitFloat32Array(results.attributes.colors);\n\t\n\t        var splitProperties;\n\t        if (results.properties) {\n\t          splitProperties = _utilBuffer2['default'].splitUint8Array(results.properties);\n\t        }\n\t\n\t        var flats = results.flats;\n\t\n\t        var objects = [];\n\t        var obj;\n\t        var pickingId;\n\t        var pickingIds;\n\t        var properties;\n\t\n\t        var polylineAttributeLengths = {\n\t          positions: 3,\n\t          colors: 3\n\t        };\n\t\n\t        for (var i = 0; i < splitPositions.length; i++) {\n\t          if (splitProperties && splitProperties[i]) {\n\t            properties = JSON.parse(_utilBuffer2['default'].uint8ArrayToString(splitProperties[i]));\n\t          } else {\n\t            properties = {};\n\t          }\n\t\n\t          // WORKERS: obj.attributes should actually an array of polygons for\n\t          // the feature, though the current logic isn't aware of that\n\t          obj = {\n\t            attributes: [{\n\t              positions: splitPositions[i],\n\t              colors: splitColors[i]\n\t            }],\n\t            properties: properties,\n\t            flat: flats[i]\n\t          };\n\t\n\t          // WORKERS: If interactive, generate unique ID for each feature, create\n\t          // the buffer attributes and set up event listeners\n\t          if (_this4._options.interactive) {\n\t            pickingId = _this4.getPickingId();\n\t\n\t            pickingIds = new Float32Array(splitPositions[i].length / 3);\n\t            pickingIds.fill(pickingId);\n\t\n\t            obj.attributes[0].pickingIds = pickingIds;\n\t\n\t            polylineAttributeLengths.pickingIds = 1;\n\t\n\t            _this4._addPicking(pickingId, properties);\n\t          }\n\t\n\t          // TODO: Make this specific to polyline attributes\n\t          if (typeof _this4._options.onAddAttributes === 'function') {\n\t            var customAttributes = _this4._options.onAddAttributes(obj.attributes[0], properties);\n\t            var customAttribute;\n\t            for (var key in customAttributes) {\n\t              customAttribute = customAttributes[key];\n\t              obj.attributes[0][key] = customAttribute.value;\n\t              polylineAttributeLengths[key] = customAttribute.length;\n\t            }\n\t          }\n\t\n\t          objects.push(obj);\n\t        }\n\t\n\t        var polylineAttributes = [];\n\t\n\t        var polylineFlat = true;\n\t\n\t        for (var i = 0; i < objects.length; i++) {\n\t          obj = objects[i];\n\t\n\t          if (polylineFlat && !obj.flat) {\n\t            polylineFlat = false;\n\t          }\n\t\n\t          var bufferAttributes = _utilBuffer2['default'].mergeAttributes(obj.attributes);\n\t          polylineAttributes.push(bufferAttributes);\n\t        };\n\t\n\t        if (polylineAttributes.length > 0) {\n\t          var mergedPolylineAttributes = _utilBuffer2['default'].mergeAttributes(polylineAttributes);\n\t\n\t          // TODO: Make this work when style is a function per feature\n\t          var style = typeof _this4._options.style === 'function' ? _this4._options.style(objects[0]) : _this4._options.style;\n\t          style = (0, _lodashAssign2['default'])({}, _utilGeoJSON2['default'].defaultStyle, style);\n\t\n\t          _this4._setPolylineMesh(mergedPolylineAttributes, polylineAttributeLengths, style, polylineFlat).then(function (result) {\n\t            _this4._polylineMesh = result.mesh;\n\t            _this4.add(_this4._polylineMesh);\n\t\n\t            if (result.pickingMesh) {\n\t              _this4._pickingMesh.add(result.pickingMesh);\n\t            }\n\t\n\t            resolve();\n\t          })['catch'](reject);\n\t        } else {\n\t          resolve();\n\t        }\n\t      });\n\t    }\n\t  }, {\n\t    key: '_processPointResults',\n\t    value: function _processPointResults(results) {\n\t      var _this5 = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        var splitPositions = _utilBuffer2['default'].splitFloat32Array(results.attributes.positions);\n\t        var splitNormals = _utilBuffer2['default'].splitFloat32Array(results.attributes.normals);\n\t        var splitColors = _utilBuffer2['default'].splitFloat32Array(results.attributes.colors);\n\t\n\t        var splitProperties;\n\t        if (results.properties) {\n\t          splitProperties = _utilBuffer2['default'].splitUint8Array(results.properties);\n\t        }\n\t\n\t        var flats = results.flats;\n\t\n\t        var objects = [];\n\t        var obj;\n\t        var pickingId;\n\t        var pickingIds;\n\t        var properties;\n\t\n\t        var pointAttributeLengths = {\n\t          positions: 3,\n\t          normals: 3,\n\t          colors: 3\n\t        };\n\t\n\t        for (var i = 0; i < splitPositions.length; i++) {\n\t          if (splitProperties && splitProperties[i]) {\n\t            properties = JSON.parse(_utilBuffer2['default'].uint8ArrayToString(splitProperties[i]));\n\t          } else {\n\t            properties = {};\n\t          }\n\t\n\t          // WORKERS: obj.attributes should actually an array of polygons for\n\t          // the feature, though the current logic isn't aware of that\n\t          obj = {\n\t            attributes: [{\n\t              positions: splitPositions[i],\n\t              normals: splitNormals[i],\n\t              colors: splitColors[i]\n\t            }],\n\t            properties: properties,\n\t            flat: flats[i]\n\t          };\n\t\n\t          // WORKERS: If interactive, generate unique ID for each feature, create\n\t          // the buffer attributes and set up event listeners\n\t          if (_this5._options.interactive) {\n\t            pickingId = _this5.getPickingId();\n\t\n\t            pickingIds = new Float32Array(splitPositions[i].length / 3);\n\t            pickingIds.fill(pickingId);\n\t\n\t            obj.attributes[0].pickingIds = pickingIds;\n\t\n\t            pointAttributeLengths.pickingIds = 1;\n\t\n\t            _this5._addPicking(pickingId, properties);\n\t          }\n\t\n\t          // TODO: Make this specific to polygon attributes\n\t          if (typeof _this5._options.onAddAttributes === 'function') {\n\t            var customAttributes = _this5._options.onAddAttributes(obj.attributes[0], properties);\n\t            var customAttribute;\n\t            for (var key in customAttributes) {\n\t              customAttribute = customAttributes[key];\n\t              obj.attributes[0][key] = customAttribute.value;\n\t              pointAttributeLengths[key] = customAttribute.length;\n\t            }\n\t          }\n\t\n\t          objects.push(obj);\n\t        }\n\t\n\t        var pointAttributes = [];\n\t\n\t        var pointFlat = true;\n\t\n\t        for (var i = 0; i < objects.length; i++) {\n\t          obj = objects[i];\n\t\n\t          if (pointFlat && !obj.flat) {\n\t            pointFlat = false;\n\t          }\n\t\n\t          var bufferAttributes = _utilBuffer2['default'].mergeAttributes(obj.attributes);\n\t          pointAttributes.push(bufferAttributes);\n\t        };\n\t\n\t        if (pointAttributes.length > 0) {\n\t          var mergedPointAttributes = _utilBuffer2['default'].mergeAttributes(pointAttributes);\n\t\n\t          // TODO: Make this work when style is a function per feature\n\t          var style = typeof _this5._options.style === 'function' ? _this5._options.style(objects[0]) : _this5._options.style;\n\t          style = (0, _lodashAssign2['default'])({}, _utilGeoJSON2['default'].defaultStyle, style);\n\t\n\t          _this5._setPointMesh(mergedPointAttributes, pointAttributeLengths, style, pointFlat).then(function (result) {\n\t            _this5._pointMesh = result.mesh;\n\t            _this5.add(_this5._pointMesh);\n\t\n\t            if (result.pickingMesh) {\n\t              _this5._pickingMesh.add(result.pickingMesh);\n\t            }\n\t\n\t            resolve();\n\t          })['catch'](reject);\n\t        } else {\n\t          resolve();\n\t        }\n\t      });\n\t    }\n\t\n\t    // TODO: At some point this needs to return all the features to the main thread\n\t    // so it can generate meshes and output to the scene, as well as perhaps creating\n\t    // individual layers / components for each feature to track things like picking\n\t    // and properties\n\t    //\n\t    // TODO: Find a way so the origin point isn't needed to be passed in as it\n\t    // feels a bit messy and against the idea of a static Geo class\n\t    //\n\t    // TODO: Support passing custom geometry for point layers\n\t  }, {\n\t    key: '_setPolygonMesh',\n\t\n\t    // Create and store mesh from buffer attributes\n\t    //\n\t    // Could make this an abstract method for each geometry layer\n\t    value: function _setPolygonMesh(attributes, attributeLengths, style, flat) {\n\t      if (!this._world) {\n\t        return Promise.reject();\n\t      }\n\t\n\t      return _geometryPolygonLayer2['default'].SetMesh(attributes, attributeLengths, flat, style, this._options, this._world._environment._skybox);\n\t    }\n\t  }, {\n\t    key: '_setPolylineMesh',\n\t    value: function _setPolylineMesh(attributes, attributeLengths, style, flat) {\n\t      if (!this._world) {\n\t        return Promise.reject();\n\t      }\n\t\n\t      return _geometryPolylineLayer2['default'].SetMesh(attributes, attributeLengths, flat, style, this._options);\n\t    }\n\t  }, {\n\t    key: '_setPointMesh',\n\t    value: function _setPointMesh(attributes, attributeLengths, style, flat) {\n\t      if (!this._world) {\n\t        return Promise.reject();\n\t      }\n\t\n\t      return _geometryPointLayer2['default'].SetMesh(attributes, attributeLengths, flat, style, this._options, this._world._environment._skybox);\n\t    }\n\t\n\t    // Set up and re-emit interaction events\n\t  }, {\n\t    key: '_addPicking',\n\t    value: function _addPicking(pickingId, properties) {\n\t      var _this6 = this;\n\t\n\t      this._world.on('pick-click-' + pickingId, function (pickingId, point2d, point3d, intersects) {\n\t        _this6._world.emit('click', _this6, properties, point2d, point3d);\n\t      });\n\t\n\t      this._world.on('pick-hover-' + pickingId, function (pickingId, point2d, point3d, intersects) {\n\t        _this6._world.emit('hover', _this6, properties, point2d, point3d);\n\t      });\n\t    }\n\t\n\t    // TODO: Finish cleanup\n\t  }, {\n\t    key: 'destroy',\n\t    value: function destroy() {\n\t      // Run common destruction logic from parent\n\t      _get(Object.getPrototypeOf(GeoJSONWorkerLayer.prototype), 'destroy', this).call(this);\n\t    }\n\t  }], [{\n\t    key: 'Process',\n\t    value: function Process(geojson, topojson, headers, originPoint, _style, _properties, _pointGeometry) {\n\t      return new Promise(function (resolve, reject) {\n\t        GeoJSONWorkerLayer.ProcessGeoJSON(geojson, headers).then(function (res) {\n\t          // Collects features into a single FeatureCollection\n\t          //\n\t          // Also converts TopoJSON to GeoJSON if instructed\n\t          var geojson = _utilGeoJSON2['default'].collectFeatures(res, topojson);\n\t\n\t          // TODO: Check that GeoJSON is valid / usable\n\t\n\t          var features = geojson.features;\n\t\n\t          // TODO: Run filter, if provided (must be static)\n\t\n\t          var pointScale;\n\t          var polygons = [];\n\t          var polylines = [];\n\t          var points = [];\n\t\n\t          // Deserialise style function if provided\n\t          if (typeof _style === 'string') {\n\t            _style = _utilStringify2['default'].stringToFunction(_style);\n\t          }\n\t\n\t          // Assume that a style won't be set per feature\n\t          var style = _style;\n\t\n\t          var pointGeometry;\n\t          // Deserialise pointGeometry function if provided\n\t          if (typeof _pointGeometry === 'string') {\n\t            pointGeometry = _utilStringify2['default'].stringToFunction(_pointGeometry);\n\t          }\n\t\n\t          var feature;\n\t          for (var i = 0; i < features.length; i++) {\n\t            feature = features[i];\n\t\n\t            var geometry = feature.geometry;\n\t            var coordinates = geometry.coordinates ? geometry.coordinates : null;\n\t\n\t            if (!coordinates || !geometry) {\n\t              return;\n\t            }\n\t\n\t            // Get per-feature style object, if provided\n\t            if (typeof _style === 'function') {\n\t              style = (0, _lodashAssign2['default'])({}, _utilGeoJSON2['default'].defaultStyle, _style(feature));\n\t              // console.log(feature, style);\n\t            }\n\t\n\t            if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {\n\t              coordinates = _geometryPolygonLayer2['default'].isSingle(coordinates) ? [coordinates] : coordinates;\n\t\n\t              var converted = coordinates.map(function (_coordinates) {\n\t                return _coordinates.map(function (ring) {\n\t                  return ring.map(function (coordinate) {\n\t                    return (0, _geoLatLon.latLon)(coordinate[1], coordinate[0]);\n\t                  });\n\t                });\n\t              });\n\t\n\t              var point;\n\t              var projected = converted.map(function (_coordinates) {\n\t                return _coordinates.map(function (ring) {\n\t                  return ring.map(function (latlon) {\n\t                    point = _geoGeo2['default'].latLonToPoint(latlon)._subtract(originPoint);\n\t\n\t                    if (!pointScale) {\n\t                      pointScale = _geoGeo2['default'].pointScale(latlon);\n\t                    }\n\t\n\t                    return point;\n\t                  });\n\t                });\n\t              });\n\t\n\t              var polygon = {\n\t                projected: projected,\n\t                options: {\n\t                  pointScale: pointScale,\n\t                  style: style\n\t                }\n\t              };\n\t\n\t              if (_properties) {\n\t                polygon.properties = feature.properties;\n\t              }\n\t\n\t              polygons.push(polygon);\n\t            }\n\t\n\t            if (geometry.type === 'LineString' || geometry.type === 'MultiLineString') {\n\t              coordinates = _geometryPolylineLayer2['default'].isSingle(coordinates) ? [coordinates] : coordinates;\n\t\n\t              var converted = coordinates.map(function (_coordinates) {\n\t                return _coordinates.map(function (coordinate) {\n\t                  return (0, _geoLatLon.latLon)(coordinate[1], coordinate[0]);\n\t                });\n\t              });\n\t\n\t              var point;\n\t              var projected = converted.map(function (_coordinates) {\n\t                return _coordinates.map(function (latlon) {\n\t                  point = _geoGeo2['default'].latLonToPoint(latlon)._subtract(originPoint);\n\t\n\t                  if (!pointScale) {\n\t                    pointScale = _geoGeo2['default'].pointScale(latlon);\n\t                  }\n\t\n\t                  return point;\n\t                });\n\t              });\n\t\n\t              var polyline = {\n\t                projected: projected,\n\t                options: {\n\t                  pointScale: pointScale,\n\t                  style: style\n\t                }\n\t              };\n\t\n\t              if (_properties) {\n\t                polyline.properties = feature.properties;\n\t              }\n\t\n\t              polylines.push(polyline);\n\t            }\n\t\n\t            if (geometry.type === 'Point' || geometry.type === 'MultiPoint') {\n\t              coordinates = _geometryPointLayer2['default'].isSingle(coordinates) ? [coordinates] : coordinates;\n\t\n\t              var converted = coordinates.map(function (coordinate) {\n\t                return (0, _geoLatLon.latLon)(coordinate[1], coordinate[0]);\n\t              });\n\t\n\t              var point;\n\t              var projected = converted.map(function (latlon) {\n\t                point = _geoGeo2['default'].latLonToPoint(latlon)._subtract(originPoint);\n\t\n\t                if (!pointScale) {\n\t                  pointScale = _geoGeo2['default'].pointScale(latlon);\n\t                }\n\t\n\t                return point;\n\t              });\n\t\n\t              var point = {\n\t                projected: projected,\n\t                options: {\n\t                  pointGeometry: pointGeometry(feature),\n\t                  pointScale: pointScale,\n\t                  style: style\n\t                }\n\t              };\n\t\n\t              if (_properties) {\n\t                point.properties = feature.properties;\n\t              }\n\t\n\t              points.push(point);\n\t            }\n\t          };\n\t\n\t          var polygonBufferPromises = [];\n\t          var polylineBufferPromises = [];\n\t          var pointBufferPromises = [];\n\t\n\t          var polygon;\n\t          for (var i = 0; i < polygons.length; i++) {\n\t            polygon = polygons[i];\n\t            polygonBufferPromises.push(_geometryPolygonLayer2['default'].SetBufferAttributes(polygon.projected, polygon.options));\n\t          };\n\t\n\t          var polyline;\n\t          for (var i = 0; i < polylines.length; i++) {\n\t            polyline = polylines[i];\n\t            polylineBufferPromises.push(_geometryPolylineLayer2['default'].SetBufferAttributes(polyline.projected, polyline.options));\n\t          };\n\t\n\t          var point;\n\t          for (var i = 0; i < points.length; i++) {\n\t            point = points[i];\n\t            pointBufferPromises.push(_geometryPointLayer2['default'].SetBufferAttributes(point.projected, point.options));\n\t          };\n\t\n\t          var data = {};\n\t          var transferrables = [];\n\t\n\t          // TODO: Make this work with polylines too\n\t          // TODO: Make this so it's not a nest of promises\n\t          GeoJSONWorkerLayer.ProcessPolygons(polygonBufferPromises, polygons, _properties).then(function (result) {\n\t            data.polygons = result.data;\n\t            transferrables = transferrables.concat(result.transferrables);\n\t\n\t            GeoJSONWorkerLayer.ProcessPolylines(polylineBufferPromises, polylines, _properties).then(function (result) {\n\t              data.polylines = result.data;\n\t              transferrables = transferrables.concat(result.transferrables);\n\t\n\t              GeoJSONWorkerLayer.ProcessPoints(pointBufferPromises, points, _properties).then(function (result) {\n\t                data.points = result.data;\n\t                transferrables = transferrables.concat(result.transferrables);\n\t\n\t                resolve({\n\t                  data: data,\n\t                  transferrables: transferrables\n\t                });\n\t              });\n\t            });\n\t          });\n\t        });\n\t      });\n\t    }\n\t  }, {\n\t    key: 'ProcessPolygons',\n\t    value: function ProcessPolygons(polygonPromises, polygons, _properties) {\n\t      return new Promise(function (resolve, reject) {\n\t        Promise.all(polygonPromises).then(function (results) {\n\t          var transferrables = [];\n\t\n\t          var positions = [];\n\t          var normals = [];\n\t          var colors = [];\n\t          var tops = [];\n\t\n\t          var outlinePositions = [];\n\t          var outlineColors = [];\n\t\n\t          var properties = [];\n\t\n\t          var flats = [];\n\t          var polygon;\n\t\n\t          var result;\n\t          for (var i = 0; i < results.length; i++) {\n\t            result = results[i];\n\t\n\t            polygon = polygons[i];\n\t\n\t            // WORKERS: Making this a typed array will speed up transfer time\n\t            // As things stand this adds on a few milliseconds\n\t            flats.push(result.flat);\n\t\n\t            // WORKERS: result.attributes is actually an array of polygons for each\n\t            // feature, though the current logic isn't keeping these all together\n\t\n\t            var attributes;\n\t            for (var j = 0; j < result.attributes.length; j++) {\n\t              attributes = result.attributes[j];\n\t\n\t              positions.push(attributes.positions);\n\t              normals.push(attributes.normals);\n\t              colors.push(attributes.colors);\n\t              tops.push(attributes.tops);\n\t\n\t              if (_properties) {\n\t                properties.push(_utilBuffer2['default'].stringToUint8Array(JSON.stringify(polygon.properties)));\n\t              }\n\t            };\n\t\n\t            var outlineAttributes;\n\t            for (var j = 0; j < result.outlineAttributes.length; j++) {\n\t              outlineAttributes = result.outlineAttributes[j];\n\t\n\t              outlinePositions.push(outlineAttributes.positions);\n\t              outlineColors.push(outlineAttributes.colors);\n\t            };\n\t          };\n\t\n\t          var mergedAttributes = {\n\t            positions: _utilBuffer2['default'].mergeFloat32Arrays(positions),\n\t            normals: _utilBuffer2['default'].mergeFloat32Arrays(normals),\n\t            colors: _utilBuffer2['default'].mergeFloat32Arrays(colors),\n\t            tops: _utilBuffer2['default'].mergeFloat32Arrays(tops)\n\t          };\n\t\n\t          var mergedOutlineAttributes = {\n\t            positions: _utilBuffer2['default'].mergeFloat32Arrays(outlinePositions),\n\t            colors: _utilBuffer2['default'].mergeFloat32Arrays(outlineColors)\n\t          };\n\t\n\t          transferrables.push(mergedAttributes.positions[0].buffer);\n\t          transferrables.push(mergedAttributes.positions[1].buffer);\n\t\n\t          transferrables.push(mergedAttributes.normals[0].buffer);\n\t          transferrables.push(mergedAttributes.normals[1].buffer);\n\t\n\t          transferrables.push(mergedAttributes.colors[0].buffer);\n\t          transferrables.push(mergedAttributes.colors[1].buffer);\n\t\n\t          transferrables.push(mergedAttributes.tops[0].buffer);\n\t          transferrables.push(mergedAttributes.tops[1].buffer);\n\t\n\t          transferrables.push(mergedOutlineAttributes.positions[0].buffer);\n\t          transferrables.push(mergedOutlineAttributes.positions[1].buffer);\n\t\n\t          transferrables.push(mergedOutlineAttributes.colors[0].buffer);\n\t          transferrables.push(mergedOutlineAttributes.colors[1].buffer);\n\t\n\t          var mergedProperties;\n\t          if (_properties) {\n\t            mergedProperties = _utilBuffer2['default'].mergeUint8Arrays(properties);\n\t\n\t            transferrables.push(mergedProperties[0].buffer);\n\t            transferrables.push(mergedProperties[1].buffer);\n\t          }\n\t\n\t          var output = {\n\t            attributes: mergedAttributes,\n\t            outlineAttributes: mergedOutlineAttributes,\n\t            flats: flats\n\t          };\n\t\n\t          if (_properties) {\n\t            output.properties = mergedProperties;\n\t          }\n\t\n\t          // TODO: Also return GeoJSON features that can be mapped to objects on\n\t          // the main thread. Allow user to provide filter / toggles to only return\n\t          // properties from the GeoJSON that they need (eg. don't return geometry,\n\t          // or don't return properties.height)\n\t          resolve({\n\t            data: output,\n\t            transferrables: transferrables\n\t          });\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'ProcessPolylines',\n\t    value: function ProcessPolylines(polylinePromises, polylines, _properties) {\n\t      return new Promise(function (resolve, reject) {\n\t        Promise.all(polylinePromises).then(function (results) {\n\t          var transferrables = [];\n\t\n\t          var positions = [];\n\t          var colors = [];\n\t\n\t          var properties = [];\n\t\n\t          var flats = [];\n\t          var polyline;\n\t\n\t          var result;\n\t          for (var i = 0; i < results.length; i++) {\n\t            result = results[i];\n\t\n\t            polyline = polylines[i];\n\t\n\t            // WORKERS: Making this a typed array will speed up transfer time\n\t            // As things stand this adds on a few milliseconds\n\t            flats.push(result.flat);\n\t\n\t            // WORKERS: result.attributes is actually an array of polygons for each\n\t            // feature, though the current logic isn't keeping these all together\n\t\n\t            var attributes;\n\t            for (var j = 0; j < result.attributes.length; j++) {\n\t              attributes = result.attributes[j];\n\t\n\t              positions.push(attributes.positions);\n\t              colors.push(attributes.colors);\n\t\n\t              if (_properties) {\n\t                properties.push(_utilBuffer2['default'].stringToUint8Array(JSON.stringify(polyline.properties)));\n\t              }\n\t            };\n\t          };\n\t\n\t          var mergedAttributes = {\n\t            positions: _utilBuffer2['default'].mergeFloat32Arrays(positions),\n\t            colors: _utilBuffer2['default'].mergeFloat32Arrays(colors)\n\t          };\n\t\n\t          transferrables.push(mergedAttributes.positions[0].buffer);\n\t          transferrables.push(mergedAttributes.positions[1].buffer);\n\t\n\t          transferrables.push(mergedAttributes.colors[0].buffer);\n\t          transferrables.push(mergedAttributes.colors[1].buffer);\n\t\n\t          var mergedProperties;\n\t          if (_properties) {\n\t            mergedProperties = _utilBuffer2['default'].mergeUint8Arrays(properties);\n\t\n\t            transferrables.push(mergedProperties[0].buffer);\n\t            transferrables.push(mergedProperties[1].buffer);\n\t          }\n\t\n\t          var output = {\n\t            attributes: mergedAttributes,\n\t            flats: flats\n\t          };\n\t\n\t          if (_properties) {\n\t            output.properties = mergedProperties;\n\t          }\n\t\n\t          // TODO: Also return GeoJSON features that can be mapped to objects on\n\t          // the main thread. Allow user to provide filter / toggles to only return\n\t          // properties from the GeoJSON that they need (eg. don't return geometry,\n\t          // or don't return properties.height)\n\t          resolve({\n\t            data: output,\n\t            transferrables: transferrables\n\t          });\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t\n\t    // TODO: Dedupe with ProcessPolygons as they are identical\n\t  }, {\n\t    key: 'ProcessPoints',\n\t    value: function ProcessPoints(pointPromises, points, _properties) {\n\t      return new Promise(function (resolve, reject) {\n\t        Promise.all(pointPromises).then(function (results) {\n\t          var transferrables = [];\n\t\n\t          var positions = [];\n\t          var normals = [];\n\t          var colors = [];\n\t\n\t          var properties = [];\n\t\n\t          var flats = [];\n\t          var point;\n\t\n\t          var result;\n\t          for (var i = 0; i < results.length; i++) {\n\t            result = results[i];\n\t\n\t            point = points[i];\n\t\n\t            // WORKERS: Making this a typed array will speed up transfer time\n\t            // As things stand this adds on a few milliseconds\n\t            flats.push(result.flat);\n\t\n\t            // WORKERS: result.attributes is actually an array of polygons for each\n\t            // feature, though the current logic isn't keeping these all together\n\t\n\t            var attributes;\n\t            for (var j = 0; j < result.attributes.length; j++) {\n\t              attributes = result.attributes[j];\n\t\n\t              positions.push(attributes.positions);\n\t              normals.push(attributes.normals);\n\t              colors.push(attributes.colors);\n\t\n\t              if (_properties) {\n\t                properties.push(_utilBuffer2['default'].stringToUint8Array(JSON.stringify(polygon.properties)));\n\t              }\n\t            };\n\t          };\n\t\n\t          var mergedAttributes = {\n\t            positions: _utilBuffer2['default'].mergeFloat32Arrays(positions),\n\t            normals: _utilBuffer2['default'].mergeFloat32Arrays(normals),\n\t            colors: _utilBuffer2['default'].mergeFloat32Arrays(colors)\n\t          };\n\t\n\t          transferrables.push(mergedAttributes.positions[0].buffer);\n\t          transferrables.push(mergedAttributes.positions[1].buffer);\n\t\n\t          transferrables.push(mergedAttributes.normals[0].buffer);\n\t          transferrables.push(mergedAttributes.normals[1].buffer);\n\t\n\t          transferrables.push(mergedAttributes.colors[0].buffer);\n\t          transferrables.push(mergedAttributes.colors[1].buffer);\n\t\n\t          var mergedProperties;\n\t          if (_properties) {\n\t            mergedProperties = _utilBuffer2['default'].mergeUint8Arrays(properties);\n\t\n\t            transferrables.push(mergedProperties[0].buffer);\n\t            transferrables.push(mergedProperties[1].buffer);\n\t          }\n\t\n\t          var output = {\n\t            attributes: mergedAttributes,\n\t            flats: flats\n\t          };\n\t\n\t          if (_properties) {\n\t            output.properties = mergedProperties;\n\t          }\n\t\n\t          // TODO: Also return GeoJSON features that can be mapped to objects on\n\t          // the main thread. Allow user to provide filter / toggles to only return\n\t          // properties from the GeoJSON that they need (eg. don't return geometry,\n\t          // or don't return properties.height)\n\t          resolve({\n\t            data: output,\n\t            transferrables: transferrables\n\t          });\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'ProcessGeoJSON',\n\t    value: function ProcessGeoJSON(geojson, headers) {\n\t      if (typeof geojson === 'string') {\n\t        return GeoJSONWorkerLayer.RequestGeoJSON(geojson, headers);\n\t      } else {\n\t        return Promise.resolve(JSON.parse(_utilBuffer2['default'].uint8ArrayToString(geojson)));\n\t      }\n\t    }\n\t  }, {\n\t    key: 'RequestGeoJSON',\n\t    value: function RequestGeoJSON(path, headers) {\n\t      return (0, _reqwest2['default'])({\n\t        url: path,\n\t        type: 'json',\n\t        crossOrigin: true,\n\t        headers: headers\n\t      });\n\t    }\n\t  }]);\n\t\n\t  return GeoJSONWorkerLayer;\n\t})(_Layer3['default']);\n\t\n\texports['default'] = GeoJSONWorkerLayer;\n\t\n\tvar noNew = function noNew(geojson, options) {\n\t  return new GeoJSONWorkerLayer(geojson, options);\n\t};\n\t\n\texports.geoJSONWorkerLayer = noNew;\n\n/***/ },\n/* 23 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n\t  * Reqwest! A general purpose XHR connection manager\n\t  * license MIT (c) Dustin Diaz 2015\n\t  * https://github.com/ded/reqwest\n\t  */\n\t\n\t!function (name, context, definition) {\n\t  if (typeof module != 'undefined' && module.exports) module.exports = definition()\n\t  else if (true) !(__WEBPACK_AMD_DEFINE_FACTORY__ = (definition), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))\n\t  else context[name] = definition()\n\t}('reqwest', this, function () {\n\t\n\t  var context = this\n\t\n\t  if ('window' in context) {\n\t    var doc = document\n\t      , byTag = 'getElementsByTagName'\n\t      , head = doc[byTag]('head')[0]\n\t  } else {\n\t    var XHR2\n\t    try {\n\t      XHR2 = __webpack_require__(24)\n\t    } catch (ex) {\n\t      throw new Error('Peer dependency `xhr2` required! Please npm install xhr2')\n\t    }\n\t  }\n\t\n\t\n\t  var httpsRe = /^http/\n\t    , protocolRe = /(^\\w+):\\/\\//\n\t    , twoHundo = /^(20\\d|1223)$/ //http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request\n\t    , readyState = 'readyState'\n\t    , contentType = 'Content-Type'\n\t    , requestedWith = 'X-Requested-With'\n\t    , uniqid = 0\n\t    , callbackPrefix = 'reqwest_' + (+new Date())\n\t    , lastValue // data stored by the most recent JSONP callback\n\t    , xmlHttpRequest = 'XMLHttpRequest'\n\t    , xDomainRequest = 'XDomainRequest'\n\t    , noop = function () {}\n\t\n\t    , isArray = typeof Array.isArray == 'function'\n\t        ? Array.isArray\n\t        : function (a) {\n\t            return a instanceof Array\n\t          }\n\t\n\t    , defaultHeaders = {\n\t          'contentType': 'application/x-www-form-urlencoded'\n\t        , 'requestedWith': xmlHttpRequest\n\t        , 'accept': {\n\t              '*':  'text/javascript, text/html, application/xml, text/xml, */*'\n\t            , 'xml':  'application/xml, text/xml'\n\t            , 'html': 'text/html'\n\t            , 'text': 'text/plain'\n\t            , 'json': 'application/json, text/javascript'\n\t            , 'js':   'application/javascript, text/javascript'\n\t          }\n\t      }\n\t\n\t    , xhr = function(o) {\n\t        // is it x-domain\n\t        if (o['crossOrigin'] === true) {\n\t          var xhr = context[xmlHttpRequest] ? new XMLHttpRequest() : null\n\t          if (xhr && 'withCredentials' in xhr) {\n\t            return xhr\n\t          } else if (context[xDomainRequest]) {\n\t            return new XDomainRequest()\n\t          } else {\n\t            throw new Error('Browser does not support cross-origin requests')\n\t          }\n\t        } else if (context[xmlHttpRequest]) {\n\t          return new XMLHttpRequest()\n\t        } else if (XHR2) {\n\t          return new XHR2()\n\t        } else {\n\t          return new ActiveXObject('Microsoft.XMLHTTP')\n\t        }\n\t      }\n\t    , globalSetupOptions = {\n\t        dataFilter: function (data) {\n\t          return data\n\t        }\n\t      }\n\t\n\t  function succeed(r) {\n\t    var protocol = protocolRe.exec(r.url)\n\t    protocol = (protocol && protocol[1]) || context.location.protocol\n\t    return httpsRe.test(protocol) ? twoHundo.test(r.request.status) : !!r.request.response\n\t  }\n\t\n\t  function handleReadyState(r, success, error) {\n\t    return function () {\n\t      // use _aborted to mitigate against IE err c00c023f\n\t      // (can't read props on aborted request objects)\n\t      if (r._aborted) return error(r.request)\n\t      if (r._timedOut) return error(r.request, 'Request is aborted: timeout')\n\t      if (r.request && r.request[readyState] == 4) {\n\t        r.request.onreadystatechange = noop\n\t        if (succeed(r)) success(r.request)\n\t        else\n\t          error(r.request)\n\t      }\n\t    }\n\t  }\n\t\n\t  function setHeaders(http, o) {\n\t    var headers = o['headers'] || {}\n\t      , h\n\t\n\t    headers['Accept'] = headers['Accept']\n\t      || defaultHeaders['accept'][o['type']]\n\t      || defaultHeaders['accept']['*']\n\t\n\t    var isAFormData = typeof FormData !== 'undefined' && (o['data'] instanceof FormData);\n\t    // breaks cross-origin requests with legacy browsers\n\t    if (!o['crossOrigin'] && !headers[requestedWith]) headers[requestedWith] = defaultHeaders['requestedWith']\n\t    if (!headers[contentType] && !isAFormData) headers[contentType] = o['contentType'] || defaultHeaders['contentType']\n\t    for (h in headers)\n\t      headers.hasOwnProperty(h) && 'setRequestHeader' in http && http.setRequestHeader(h, headers[h])\n\t  }\n\t\n\t  function setCredentials(http, o) {\n\t    if (typeof o['withCredentials'] !== 'undefined' && typeof http.withCredentials !== 'undefined') {\n\t      http.withCredentials = !!o['withCredentials']\n\t    }\n\t  }\n\t\n\t  function generalCallback(data) {\n\t    lastValue = data\n\t  }\n\t\n\t  function urlappend (url, s) {\n\t    return url + (/\\?/.test(url) ? '&' : '?') + s\n\t  }\n\t\n\t  function handleJsonp(o, fn, err, url) {\n\t    var reqId = uniqid++\n\t      , cbkey = o['jsonpCallback'] || 'callback' // the 'callback' key\n\t      , cbval = o['jsonpCallbackName'] || reqwest.getcallbackPrefix(reqId)\n\t      , cbreg = new RegExp('((^|\\\\?|&)' + cbkey + ')=([^&]+)')\n\t      , match = url.match(cbreg)\n\t      , script = doc.createElement('script')\n\t      , loaded = 0\n\t      , isIE10 = navigator.userAgent.indexOf('MSIE 10.0') !== -1\n\t\n\t    if (match) {\n\t      if (match[3] === '?') {\n\t        url = url.replace(cbreg, '$1=' + cbval) // wildcard callback func name\n\t      } else {\n\t        cbval = match[3] // provided callback func name\n\t      }\n\t    } else {\n\t      url = urlappend(url, cbkey + '=' + cbval) // no callback details, add 'em\n\t    }\n\t\n\t    context[cbval] = generalCallback\n\t\n\t    script.type = 'text/javascript'\n\t    script.src = url\n\t    script.async = true\n\t    if (typeof script.onreadystatechange !== 'undefined' && !isIE10) {\n\t      // need this for IE due to out-of-order onreadystatechange(), binding script\n\t      // execution to an event listener gives us control over when the script\n\t      // is executed. See http://jaubourg.net/2010/07/loading-script-as-onclick-handler-of.html\n\t      script.htmlFor = script.id = '_reqwest_' + reqId\n\t    }\n\t\n\t    script.onload = script.onreadystatechange = function () {\n\t      if ((script[readyState] && script[readyState] !== 'complete' && script[readyState] !== 'loaded') || loaded) {\n\t        return false\n\t      }\n\t      script.onload = script.onreadystatechange = null\n\t      script.onclick && script.onclick()\n\t      // Call the user callback with the last value stored and clean up values and scripts.\n\t      fn(lastValue)\n\t      lastValue = undefined\n\t      head.removeChild(script)\n\t      loaded = 1\n\t    }\n\t\n\t    // Add the script to the DOM head\n\t    head.appendChild(script)\n\t\n\t    // Enable JSONP timeout\n\t    return {\n\t      abort: function () {\n\t        script.onload = script.onreadystatechange = null\n\t        err({}, 'Request is aborted: timeout', {})\n\t        lastValue = undefined\n\t        head.removeChild(script)\n\t        loaded = 1\n\t      }\n\t    }\n\t  }\n\t\n\t  function getRequest(fn, err) {\n\t    var o = this.o\n\t      , method = (o['method'] || 'GET').toUpperCase()\n\t      , url = typeof o === 'string' ? o : o['url']\n\t      // convert non-string objects to query-string form unless o['processData'] is false\n\t      , data = (o['processData'] !== false && o['data'] && typeof o['data'] !== 'string')\n\t        ? reqwest.toQueryString(o['data'])\n\t        : (o['data'] || null)\n\t      , http\n\t      , sendWait = false\n\t\n\t    // if we're working on a GET request and we have data then we should append\n\t    // query string to end of URL and not post data\n\t    if ((o['type'] == 'jsonp' || method == 'GET') && data) {\n\t      url = urlappend(url, data)\n\t      data = null\n\t    }\n\t\n\t    if (o['type'] == 'jsonp') return handleJsonp(o, fn, err, url)\n\t\n\t    // get the xhr from the factory if passed\n\t    // if the factory returns null, fall-back to ours\n\t    http = (o.xhr && o.xhr(o)) || xhr(o)\n\t\n\t    http.open(method, url, o['async'] === false ? false : true)\n\t    setHeaders(http, o)\n\t    setCredentials(http, o)\n\t    if (context[xDomainRequest] && http instanceof context[xDomainRequest]) {\n\t        http.onload = fn\n\t        http.onerror = err\n\t        // NOTE: see\n\t        // http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/30ef3add-767c-4436-b8a9-f1ca19b4812e\n\t        http.onprogress = function() {}\n\t        sendWait = true\n\t    } else {\n\t      http.onreadystatechange = handleReadyState(this, fn, err)\n\t    }\n\t    o['before'] && o['before'](http)\n\t    if (sendWait) {\n\t      setTimeout(function () {\n\t        http.send(data)\n\t      }, 200)\n\t    } else {\n\t      http.send(data)\n\t    }\n\t    return http\n\t  }\n\t\n\t  function Reqwest(o, fn) {\n\t    this.o = o\n\t    this.fn = fn\n\t\n\t    init.apply(this, arguments)\n\t  }\n\t\n\t  function setType(header) {\n\t    // json, javascript, text/plain, text/html, xml\n\t    if (header === null) return undefined; //In case of no content-type.\n\t    if (header.match('json')) return 'json'\n\t    if (header.match('javascript')) return 'js'\n\t    if (header.match('text')) return 'html'\n\t    if (header.match('xml')) return 'xml'\n\t  }\n\t\n\t  function init(o, fn) {\n\t\n\t    this.url = typeof o == 'string' ? o : o['url']\n\t    this.timeout = null\n\t\n\t    // whether request has been fulfilled for purpose\n\t    // of tracking the Promises\n\t    this._fulfilled = false\n\t    // success handlers\n\t    this._successHandler = function(){}\n\t    this._fulfillmentHandlers = []\n\t    // error handlers\n\t    this._errorHandlers = []\n\t    // complete (both success and fail) handlers\n\t    this._completeHandlers = []\n\t    this._erred = false\n\t    this._responseArgs = {}\n\t\n\t    var self = this\n\t\n\t    fn = fn || function () {}\n\t\n\t    if (o['timeout']) {\n\t      this.timeout = setTimeout(function () {\n\t        timedOut()\n\t      }, o['timeout'])\n\t    }\n\t\n\t    if (o['success']) {\n\t      this._successHandler = function () {\n\t        o['success'].apply(o, arguments)\n\t      }\n\t    }\n\t\n\t    if (o['error']) {\n\t      this._errorHandlers.push(function () {\n\t        o['error'].apply(o, arguments)\n\t      })\n\t    }\n\t\n\t    if (o['complete']) {\n\t      this._completeHandlers.push(function () {\n\t        o['complete'].apply(o, arguments)\n\t      })\n\t    }\n\t\n\t    function complete (resp) {\n\t      o['timeout'] && clearTimeout(self.timeout)\n\t      self.timeout = null\n\t      while (self._completeHandlers.length > 0) {\n\t        self._completeHandlers.shift()(resp)\n\t      }\n\t    }\n\t\n\t    function success (resp) {\n\t      var type = o['type'] || resp && setType(resp.getResponseHeader('Content-Type')) // resp can be undefined in IE\n\t      resp = (type !== 'jsonp') ? self.request : resp\n\t      // use global data filter on response text\n\t      var filteredResponse = globalSetupOptions.dataFilter(resp.responseText, type)\n\t        , r = filteredResponse\n\t      try {\n\t        resp.responseText = r\n\t      } catch (e) {\n\t        // can't assign this in IE<=8, just ignore\n\t      }\n\t      if (r) {\n\t        switch (type) {\n\t        case 'json':\n\t          try {\n\t            resp = context.JSON ? context.JSON.parse(r) : eval('(' + r + ')')\n\t          } catch (err) {\n\t            return error(resp, 'Could not parse JSON in response', err)\n\t          }\n\t          break\n\t        case 'js':\n\t          resp = eval(r)\n\t          break\n\t        case 'html':\n\t          resp = r\n\t          break\n\t        case 'xml':\n\t          resp = resp.responseXML\n\t              && resp.responseXML.parseError // IE trololo\n\t              && resp.responseXML.parseError.errorCode\n\t              && resp.responseXML.parseError.reason\n\t            ? null\n\t            : resp.responseXML\n\t          break\n\t        }\n\t      }\n\t\n\t      self._responseArgs.resp = resp\n\t      self._fulfilled = true\n\t      fn(resp)\n\t      self._successHandler(resp)\n\t      while (self._fulfillmentHandlers.length > 0) {\n\t        resp = self._fulfillmentHandlers.shift()(resp)\n\t      }\n\t\n\t      complete(resp)\n\t    }\n\t\n\t    function timedOut() {\n\t      self._timedOut = true\n\t      self.request.abort()\n\t    }\n\t\n\t    function error(resp, msg, t) {\n\t      resp = self.request\n\t      self._responseArgs.resp = resp\n\t      self._responseArgs.msg = msg\n\t      self._responseArgs.t = t\n\t      self._erred = true\n\t      while (self._errorHandlers.length > 0) {\n\t        self._errorHandlers.shift()(resp, msg, t)\n\t      }\n\t      complete(resp)\n\t    }\n\t\n\t    this.request = getRequest.call(this, success, error)\n\t  }\n\t\n\t  Reqwest.prototype = {\n\t    abort: function () {\n\t      this._aborted = true\n\t      this.request.abort()\n\t    }\n\t\n\t  , retry: function () {\n\t      init.call(this, this.o, this.fn)\n\t    }\n\t\n\t    /**\n\t     * Small deviation from the Promises A CommonJs specification\n\t     * http://wiki.commonjs.org/wiki/Promises/A\n\t     */\n\t\n\t    /**\n\t     * `then` will execute upon successful requests\n\t     */\n\t  , then: function (success, fail) {\n\t      success = success || function () {}\n\t      fail = fail || function () {}\n\t      if (this._fulfilled) {\n\t        this._responseArgs.resp = success(this._responseArgs.resp)\n\t      } else if (this._erred) {\n\t        fail(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t)\n\t      } else {\n\t        this._fulfillmentHandlers.push(success)\n\t        this._errorHandlers.push(fail)\n\t      }\n\t      return this\n\t    }\n\t\n\t    /**\n\t     * `always` will execute whether the request succeeds or fails\n\t     */\n\t  , always: function (fn) {\n\t      if (this._fulfilled || this._erred) {\n\t        fn(this._responseArgs.resp)\n\t      } else {\n\t        this._completeHandlers.push(fn)\n\t      }\n\t      return this\n\t    }\n\t\n\t    /**\n\t     * `fail` will execute when the request fails\n\t     */\n\t  , fail: function (fn) {\n\t      if (this._erred) {\n\t        fn(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t)\n\t      } else {\n\t        this._errorHandlers.push(fn)\n\t      }\n\t      return this\n\t    }\n\t  , 'catch': function (fn) {\n\t      return this.fail(fn)\n\t    }\n\t  }\n\t\n\t  function reqwest(o, fn) {\n\t    return new Reqwest(o, fn)\n\t  }\n\t\n\t  // normalize newline variants according to spec -> CRLF\n\t  function normalize(s) {\n\t    return s ? s.replace(/\\r?\\n/g, '\\r\\n') : ''\n\t  }\n\t\n\t  function serial(el, cb) {\n\t    var n = el.name\n\t      , t = el.tagName.toLowerCase()\n\t      , optCb = function (o) {\n\t          // IE gives value=\"\" even where there is no value attribute\n\t          // 'specified' ref: http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-862529273\n\t          if (o && !o['disabled'])\n\t            cb(n, normalize(o['attributes']['value'] && o['attributes']['value']['specified'] ? o['value'] : o['text']))\n\t        }\n\t      , ch, ra, val, i\n\t\n\t    // don't serialize elements that are disabled or without a name\n\t    if (el.disabled || !n) return\n\t\n\t    switch (t) {\n\t    case 'input':\n\t      if (!/reset|button|image|file/i.test(el.type)) {\n\t        ch = /checkbox/i.test(el.type)\n\t        ra = /radio/i.test(el.type)\n\t        val = el.value\n\t        // WebKit gives us \"\" instead of \"on\" if a checkbox has no value, so correct it here\n\t        ;(!(ch || ra) || el.checked) && cb(n, normalize(ch && val === '' ? 'on' : val))\n\t      }\n\t      break\n\t    case 'textarea':\n\t      cb(n, normalize(el.value))\n\t      break\n\t    case 'select':\n\t      if (el.type.toLowerCase() === 'select-one') {\n\t        optCb(el.selectedIndex >= 0 ? el.options[el.selectedIndex] : null)\n\t      } else {\n\t        for (i = 0; el.length && i < el.length; i++) {\n\t          el.options[i].selected && optCb(el.options[i])\n\t        }\n\t      }\n\t      break\n\t    }\n\t  }\n\t\n\t  // collect up all form elements found from the passed argument elements all\n\t  // the way down to child elements; pass a '<form>' or form fields.\n\t  // called with 'this'=callback to use for serial() on each element\n\t  function eachFormElement() {\n\t    var cb = this\n\t      , e, i\n\t      , serializeSubtags = function (e, tags) {\n\t          var i, j, fa\n\t          for (i = 0; i < tags.length; i++) {\n\t            fa = e[byTag](tags[i])\n\t            for (j = 0; j < fa.length; j++) serial(fa[j], cb)\n\t          }\n\t        }\n\t\n\t    for (i = 0; i < arguments.length; i++) {\n\t      e = arguments[i]\n\t      if (/input|select|textarea/i.test(e.tagName)) serial(e, cb)\n\t      serializeSubtags(e, [ 'input', 'select', 'textarea' ])\n\t    }\n\t  }\n\t\n\t  // standard query string style serialization\n\t  function serializeQueryString() {\n\t    return reqwest.toQueryString(reqwest.serializeArray.apply(null, arguments))\n\t  }\n\t\n\t  // { 'name': 'value', ... } style serialization\n\t  function serializeHash() {\n\t    var hash = {}\n\t    eachFormElement.apply(function (name, value) {\n\t      if (name in hash) {\n\t        hash[name] && !isArray(hash[name]) && (hash[name] = [hash[name]])\n\t        hash[name].push(value)\n\t      } else hash[name] = value\n\t    }, arguments)\n\t    return hash\n\t  }\n\t\n\t  // [ { name: 'name', value: 'value' }, ... ] style serialization\n\t  reqwest.serializeArray = function () {\n\t    var arr = []\n\t    eachFormElement.apply(function (name, value) {\n\t      arr.push({name: name, value: value})\n\t    }, arguments)\n\t    return arr\n\t  }\n\t\n\t  reqwest.serialize = function () {\n\t    if (arguments.length === 0) return ''\n\t    var opt, fn\n\t      , args = Array.prototype.slice.call(arguments, 0)\n\t\n\t    opt = args.pop()\n\t    opt && opt.nodeType && args.push(opt) && (opt = null)\n\t    opt && (opt = opt.type)\n\t\n\t    if (opt == 'map') fn = serializeHash\n\t    else if (opt == 'array') fn = reqwest.serializeArray\n\t    else fn = serializeQueryString\n\t\n\t    return fn.apply(null, args)\n\t  }\n\t\n\t  reqwest.toQueryString = function (o, trad) {\n\t    var prefix, i\n\t      , traditional = trad || false\n\t      , s = []\n\t      , enc = encodeURIComponent\n\t      , add = function (key, value) {\n\t          // If value is a function, invoke it and return its value\n\t          value = ('function' === typeof value) ? value() : (value == null ? '' : value)\n\t          s[s.length] = enc(key) + '=' + enc(value)\n\t        }\n\t    // If an array was passed in, assume that it is an array of form elements.\n\t    if (isArray(o)) {\n\t      for (i = 0; o && i < o.length; i++) add(o[i]['name'], o[i]['value'])\n\t    } else {\n\t      // If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t      // did it), otherwise encode params recursively.\n\t      for (prefix in o) {\n\t        if (o.hasOwnProperty(prefix)) buildParams(prefix, o[prefix], traditional, add)\n\t      }\n\t    }\n\t\n\t    // spaces should be + according to spec\n\t    return s.join('&').replace(/%20/g, '+')\n\t  }\n\t\n\t  function buildParams(prefix, obj, traditional, add) {\n\t    var name, i, v\n\t      , rbracket = /\\[\\]$/\n\t\n\t    if (isArray(obj)) {\n\t      // Serialize array item.\n\t      for (i = 0; obj && i < obj.length; i++) {\n\t        v = obj[i]\n\t        if (traditional || rbracket.test(prefix)) {\n\t          // Treat each array item as a scalar.\n\t          add(prefix, v)\n\t        } else {\n\t          buildParams(prefix + '[' + (typeof v === 'object' ? i : '') + ']', v, traditional, add)\n\t        }\n\t      }\n\t    } else if (obj && obj.toString() === '[object Object]') {\n\t      // Serialize object item.\n\t      for (name in obj) {\n\t        buildParams(prefix + '[' + name + ']', obj[name], traditional, add)\n\t      }\n\t\n\t    } else {\n\t      // Serialize scalar item.\n\t      add(prefix, obj)\n\t    }\n\t  }\n\t\n\t  reqwest.getcallbackPrefix = function () {\n\t    return callbackPrefix\n\t  }\n\t\n\t  // jQuery and Zepto compatibility, differences can be remapped here so you can call\n\t  // .ajax.compat(options, callback)\n\t  reqwest.compat = function (o, fn) {\n\t    if (o) {\n\t      o['type'] && (o['method'] = o['type']) && delete o['type']\n\t      o['dataType'] && (o['type'] = o['dataType'])\n\t      o['jsonpCallback'] && (o['jsonpCallbackName'] = o['jsonpCallback']) && delete o['jsonpCallback']\n\t      o['jsonp'] && (o['jsonpCallback'] = o['jsonp'])\n\t    }\n\t    return new Reqwest(o, fn)\n\t  }\n\t\n\t  reqwest.ajaxSetup = function (options) {\n\t    options = options || {}\n\t    for (var k in options) {\n\t      globalSetupOptions[k] = options[k]\n\t    }\n\t  }\n\t\n\t  return reqwest\n\t});\n\n\n/***/ },\n/* 24 */\n/***/ function(module, exports) {\n\n\t/* (ignored) */\n\n/***/ },\n/* 25 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t/*\n\t * GeoJSON helpers for handling data and generating objects\n\t */\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _topojson2 = __webpack_require__(26);\n\t\n\tvar topojson = _interopRequireWildcard(_topojson2);\n\t\n\tvar _geojsonMerge = __webpack_require__(27);\n\t\n\tvar _geojsonMerge2 = _interopRequireDefault(_geojsonMerge);\n\t\n\tvar _earcut = __webpack_require__(29);\n\t\n\tvar _earcut2 = _interopRequireDefault(_earcut);\n\t\n\tvar _extrudePolygon = __webpack_require__(30);\n\t\n\tvar _extrudePolygon2 = _interopRequireDefault(_extrudePolygon);\n\t\n\t// TODO: Make it so height can be per-coordinate / point but connected together\n\t// as a linestring (eg. GPS points with an elevation at each point)\n\t//\n\t// This isn't really valid GeoJSON so perhaps something best left to an external\n\t// component for now, until a better approach can be considered\n\t//\n\t// See: http://lists.geojson.org/pipermail/geojson-geojson.org/2009-June/000489.html\n\t\n\t// Light and dark colours used for poor-mans AO gradient on object sides\n\tvar light = new _three2['default'].Color(0xffffff);\n\tvar shadow = new _three2['default'].Color(0x666666);\n\t\n\tvar GeoJSON = (function () {\n\t  var defaultStyle = {\n\t    color: '#ffffff',\n\t    outline: false,\n\t    outlineColor: '#000000',\n\t    transparent: false,\n\t    opacity: 1,\n\t    blending: _three2['default'].NormalBlending,\n\t    height: 0,\n\t    lineOpacity: 1,\n\t    lineTransparent: false,\n\t    lineColor: '#ffffff',\n\t    lineWidth: 1,\n\t    lineBlending: _three2['default'].NormalBlending\n\t  };\n\t\n\t  // Attempts to merge together multiple GeoJSON Features or FeatureCollections\n\t  // into a single FeatureCollection\n\t  var collectFeatures = function collectFeatures(data, _topojson) {\n\t    var collections = [];\n\t\n\t    if (_topojson) {\n\t      // TODO: Allow TopoJSON objects to be overridden as an option\n\t\n\t      // If not overridden, merge all features from all objects\n\t      for (var tk in data.objects) {\n\t        collections.push(topojson.feature(data, data.objects[tk]));\n\t      }\n\t\n\t      return (0, _geojsonMerge2['default'])(collections);\n\t    } else {\n\t      // If root doesn't have a type then let's see if there are features in the\n\t      // next step down\n\t      if (!data.type) {\n\t        // TODO: Allow GeoJSON objects to be overridden as an option\n\t\n\t        // If not overridden, merge all features from all objects\n\t        for (var gk in data) {\n\t          if (!data[gk].type) {\n\t            continue;\n\t          }\n\t\n\t          collections.push(data[gk]);\n\t        }\n\t\n\t        return (0, _geojsonMerge2['default'])(collections);\n\t      } else if (Array.isArray(data)) {\n\t        return (0, _geojsonMerge2['default'])(data);\n\t      } else {\n\t        return data;\n\t      }\n\t    }\n\t  };\n\t\n\t  // TODO: This is only used by GeoJSONTile so either roll it into that or\n\t  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n\t  var lineStringAttributes = function lineStringAttributes(coordinates, colour, height) {\n\t    var _coords = [];\n\t    var _colours = [];\n\t\n\t    var nextCoord;\n\t\n\t    // Connect coordinate with the next to make a pair\n\t    //\n\t    // LineSegments requires pairs of vertices so repeat the last point if\n\t    // there's an odd number of vertices\n\t    coordinates.forEach(function (coordinate, index) {\n\t      _colours.push([colour.r, colour.g, colour.b]);\n\t      _coords.push([coordinate[0], height, coordinate[1]]);\n\t\n\t      nextCoord = coordinates[index + 1] ? coordinates[index + 1] : coordinate;\n\t\n\t      _colours.push([colour.r, colour.g, colour.b]);\n\t      _coords.push([nextCoord[0], height, nextCoord[1]]);\n\t    });\n\t\n\t    return {\n\t      vertices: _coords,\n\t      colours: _colours\n\t    };\n\t  };\n\t\n\t  // TODO: This is only used by GeoJSONTile so either roll it into that or\n\t  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n\t  var multiLineStringAttributes = function multiLineStringAttributes(coordinates, colour, height) {\n\t    var _coords = [];\n\t    var _colours = [];\n\t\n\t    var result;\n\t    coordinates.forEach(function (coordinate) {\n\t      result = lineStringAttributes(coordinate, colour, height);\n\t\n\t      result.vertices.forEach(function (coord) {\n\t        _coords.push(coord);\n\t      });\n\t\n\t      result.colours.forEach(function (colour) {\n\t        _colours.push(colour);\n\t      });\n\t    });\n\t\n\t    return {\n\t      vertices: _coords,\n\t      colours: _colours\n\t    };\n\t  };\n\t\n\t  // TODO: This is only used by GeoJSONTile so either roll it into that or\n\t  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n\t  var polygonAttributes = function polygonAttributes(coordinates, colour, height) {\n\t    var earcutData = _toEarcut(coordinates);\n\t\n\t    var faces = _triangulate(earcutData.vertices, earcutData.holes, earcutData.dimensions);\n\t\n\t    var groupedVertices = [];\n\t    for (i = 0, il = earcutData.vertices.length; i < il; i += earcutData.dimensions) {\n\t      groupedVertices.push(earcutData.vertices.slice(i, i + earcutData.dimensions));\n\t    }\n\t\n\t    var extruded = (0, _extrudePolygon2['default'])(groupedVertices, faces, {\n\t      bottom: 0,\n\t      top: height\n\t    });\n\t\n\t    var topColor = colour.clone().multiply(light);\n\t    var bottomColor = colour.clone().multiply(shadow);\n\t\n\t    var _vertices = extruded.positions;\n\t    var _faces = [];\n\t    var _colours = [];\n\t\n\t    var _colour;\n\t    extruded.top.forEach(function (face, fi) {\n\t      _colour = [];\n\t\n\t      _colour.push([colour.r, colour.g, colour.b]);\n\t      _colour.push([colour.r, colour.g, colour.b]);\n\t      _colour.push([colour.r, colour.g, colour.b]);\n\t\n\t      _faces.push(face);\n\t      _colours.push(_colour);\n\t    });\n\t\n\t    var allFlat = true;\n\t\n\t    if (extruded.sides) {\n\t      if (allFlat) {\n\t        allFlat = false;\n\t      }\n\t\n\t      // Set up colours for every vertex with poor-mans AO on the sides\n\t      extruded.sides.forEach(function (face, fi) {\n\t        _colour = [];\n\t\n\t        // First face is always bottom-bottom-top\n\t        if (fi % 2 === 0) {\n\t          _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\t          _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\t          _colour.push([topColor.r, topColor.g, topColor.b]);\n\t          // Reverse winding for the second face\n\t          // top-top-bottom\n\t        } else {\n\t            _colour.push([topColor.r, topColor.g, topColor.b]);\n\t            _colour.push([topColor.r, topColor.g, topColor.b]);\n\t            _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\t          }\n\t\n\t        _faces.push(face);\n\t        _colours.push(_colour);\n\t      });\n\t    }\n\t\n\t    // Skip bottom as there's no point rendering it\n\t    // allFaces.push(extruded.faces);\n\t\n\t    return {\n\t      vertices: _vertices,\n\t      faces: _faces,\n\t      colours: _colours,\n\t      flat: allFlat\n\t    };\n\t  };\n\t\n\t  // TODO: This is only used by GeoJSONTile so either roll it into that or\n\t  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n\t  var _toEarcut = function _toEarcut(data) {\n\t    var dim = data[0][0].length;\n\t    var result = { vertices: [], holes: [], dimensions: dim };\n\t    var holeIndex = 0;\n\t\n\t    for (var i = 0; i < data.length; i++) {\n\t      for (var j = 0; j < data[i].length; j++) {\n\t        for (var d = 0; d < dim; d++) {\n\t          result.vertices.push(data[i][j][d]);\n\t        }\n\t      }\n\t      if (i > 0) {\n\t        holeIndex += data[i - 1].length;\n\t        result.holes.push(holeIndex);\n\t      }\n\t    }\n\t\n\t    return result;\n\t  };\n\t\n\t  // TODO: This is only used by GeoJSONTile so either roll it into that or\n\t  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n\t  var _triangulate = function _triangulate(contour, holes, dim) {\n\t    // console.time('earcut');\n\t\n\t    var faces = (0, _earcut2['default'])(contour, holes, dim);\n\t    var result = [];\n\t\n\t    for (i = 0, il = faces.length; i < il; i += 3) {\n\t      result.push(faces.slice(i, i + 3));\n\t    }\n\t\n\t    // console.timeEnd('earcut');\n\t\n\t    return result;\n\t  };\n\t\n\t  return {\n\t    defaultStyle: defaultStyle,\n\t    collectFeatures: collectFeatures,\n\t    lineStringAttributes: lineStringAttributes,\n\t    multiLineStringAttributes: multiLineStringAttributes,\n\t    polygonAttributes: polygonAttributes\n\t  };\n\t})();\n\t\n\texports['default'] = GeoJSON;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 26 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t(function (global, factory) {\n\t   true ? factory(exports) :\n\t  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t  (factory((global.topojson = global.topojson || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tfunction noop() {}\n\t\n\tfunction transformAbsolute(transform) {\n\t  if (!transform) return noop;\n\t  var x0,\n\t      y0,\n\t      kx = transform.scale[0],\n\t      ky = transform.scale[1],\n\t      dx = transform.translate[0],\n\t      dy = transform.translate[1];\n\t  return function(point, i) {\n\t    if (!i) x0 = y0 = 0;\n\t    point[0] = (x0 += point[0]) * kx + dx;\n\t    point[1] = (y0 += point[1]) * ky + dy;\n\t  };\n\t}\n\t\n\tfunction transformRelative(transform) {\n\t  if (!transform) return noop;\n\t  var x0,\n\t      y0,\n\t      kx = transform.scale[0],\n\t      ky = transform.scale[1],\n\t      dx = transform.translate[0],\n\t      dy = transform.translate[1];\n\t  return function(point, i) {\n\t    if (!i) x0 = y0 = 0;\n\t    var x1 = Math.round((point[0] - dx) / kx),\n\t        y1 = Math.round((point[1] - dy) / ky);\n\t    point[0] = x1 - x0;\n\t    point[1] = y1 - y0;\n\t    x0 = x1;\n\t    y0 = y1;\n\t  };\n\t}\n\t\n\tfunction reverse(array, n) {\n\t  var t, j = array.length, i = j - n;\n\t  while (i < --j) t = array[i], array[i++] = array[j], array[j] = t;\n\t}\n\t\n\tfunction bisect(a, x) {\n\t  var lo = 0, hi = a.length;\n\t  while (lo < hi) {\n\t    var mid = lo + hi >>> 1;\n\t    if (a[mid] < x) lo = mid + 1;\n\t    else hi = mid;\n\t  }\n\t  return lo;\n\t}\n\t\n\tfunction feature(topology, o) {\n\t  return o.type === \"GeometryCollection\" ? {\n\t    type: \"FeatureCollection\",\n\t    features: o.geometries.map(function(o) { return feature$1(topology, o); })\n\t  } : feature$1(topology, o);\n\t}\n\t\n\tfunction feature$1(topology, o) {\n\t  var f = {\n\t    type: \"Feature\",\n\t    id: o.id,\n\t    properties: o.properties || {},\n\t    geometry: object(topology, o)\n\t  };\n\t  if (o.id == null) delete f.id;\n\t  return f;\n\t}\n\t\n\tfunction object(topology, o) {\n\t  var absolute = transformAbsolute(topology.transform),\n\t      arcs = topology.arcs;\n\t\n\t  function arc(i, points) {\n\t    if (points.length) points.pop();\n\t    for (var a = arcs[i < 0 ? ~i : i], k = 0, n = a.length, p; k < n; ++k) {\n\t      points.push(p = a[k].slice());\n\t      absolute(p, k);\n\t    }\n\t    if (i < 0) reverse(points, n);\n\t  }\n\t\n\t  function point(p) {\n\t    p = p.slice();\n\t    absolute(p, 0);\n\t    return p;\n\t  }\n\t\n\t  function line(arcs) {\n\t    var points = [];\n\t    for (var i = 0, n = arcs.length; i < n; ++i) arc(arcs[i], points);\n\t    if (points.length < 2) points.push(points[0].slice());\n\t    return points;\n\t  }\n\t\n\t  function ring(arcs) {\n\t    var points = line(arcs);\n\t    while (points.length < 4) points.push(points[0].slice());\n\t    return points;\n\t  }\n\t\n\t  function polygon(arcs) {\n\t    return arcs.map(ring);\n\t  }\n\t\n\t  function geometry(o) {\n\t    var t = o.type;\n\t    return t === \"GeometryCollection\" ? {type: t, geometries: o.geometries.map(geometry)}\n\t        : t in geometryType ? {type: t, coordinates: geometryType[t](o)}\n\t        : null;\n\t  }\n\t\n\t  var geometryType = {\n\t    Point: function(o) { return point(o.coordinates); },\n\t    MultiPoint: function(o) { return o.coordinates.map(point); },\n\t    LineString: function(o) { return line(o.arcs); },\n\t    MultiLineString: function(o) { return o.arcs.map(line); },\n\t    Polygon: function(o) { return polygon(o.arcs); },\n\t    MultiPolygon: function(o) { return o.arcs.map(polygon); }\n\t  };\n\t\n\t  return geometry(o);\n\t}\n\t\n\tfunction stitchArcs(topology, arcs) {\n\t  var stitchedArcs = {},\n\t      fragmentByStart = {},\n\t      fragmentByEnd = {},\n\t      fragments = [],\n\t      emptyIndex = -1;\n\t\n\t  // Stitch empty arcs first, since they may be subsumed by other arcs.\n\t  arcs.forEach(function(i, j) {\n\t    var arc = topology.arcs[i < 0 ? ~i : i], t;\n\t    if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {\n\t      t = arcs[++emptyIndex], arcs[emptyIndex] = i, arcs[j] = t;\n\t    }\n\t  });\n\t\n\t  arcs.forEach(function(i) {\n\t    var e = ends(i),\n\t        start = e[0],\n\t        end = e[1],\n\t        f, g;\n\t\n\t    if (f = fragmentByEnd[start]) {\n\t      delete fragmentByEnd[f.end];\n\t      f.push(i);\n\t      f.end = end;\n\t      if (g = fragmentByStart[end]) {\n\t        delete fragmentByStart[g.start];\n\t        var fg = g === f ? f : f.concat(g);\n\t        fragmentByStart[fg.start = f.start] = fragmentByEnd[fg.end = g.end] = fg;\n\t      } else {\n\t        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n\t      }\n\t    } else if (f = fragmentByStart[end]) {\n\t      delete fragmentByStart[f.start];\n\t      f.unshift(i);\n\t      f.start = start;\n\t      if (g = fragmentByEnd[start]) {\n\t        delete fragmentByEnd[g.end];\n\t        var gf = g === f ? f : g.concat(f);\n\t        fragmentByStart[gf.start = g.start] = fragmentByEnd[gf.end = f.end] = gf;\n\t      } else {\n\t        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n\t      }\n\t    } else {\n\t      f = [i];\n\t      fragmentByStart[f.start = start] = fragmentByEnd[f.end = end] = f;\n\t    }\n\t  });\n\t\n\t  function ends(i) {\n\t    var arc = topology.arcs[i < 0 ? ~i : i], p0 = arc[0], p1;\n\t    if (topology.transform) p1 = [0, 0], arc.forEach(function(dp) { p1[0] += dp[0], p1[1] += dp[1]; });\n\t    else p1 = arc[arc.length - 1];\n\t    return i < 0 ? [p1, p0] : [p0, p1];\n\t  }\n\t\n\t  function flush(fragmentByEnd, fragmentByStart) {\n\t    for (var k in fragmentByEnd) {\n\t      var f = fragmentByEnd[k];\n\t      delete fragmentByStart[f.start];\n\t      delete f.start;\n\t      delete f.end;\n\t      f.forEach(function(i) { stitchedArcs[i < 0 ? ~i : i] = 1; });\n\t      fragments.push(f);\n\t    }\n\t  }\n\t\n\t  flush(fragmentByEnd, fragmentByStart);\n\t  flush(fragmentByStart, fragmentByEnd);\n\t  arcs.forEach(function(i) { if (!stitchedArcs[i < 0 ? ~i : i]) fragments.push([i]); });\n\t\n\t  return fragments;\n\t}\n\t\n\tfunction mesh(topology) {\n\t  return object(topology, meshArcs.apply(this, arguments));\n\t}\n\t\n\tfunction meshArcs(topology, o, filter) {\n\t  var arcs = [];\n\t\n\t  function arc(i) {\n\t    var j = i < 0 ? ~i : i;\n\t    (geomsByArc[j] || (geomsByArc[j] = [])).push({i: i, g: geom});\n\t  }\n\t\n\t  function line(arcs) {\n\t    arcs.forEach(arc);\n\t  }\n\t\n\t  function polygon(arcs) {\n\t    arcs.forEach(line);\n\t  }\n\t\n\t  function geometry(o) {\n\t    if (o.type === \"GeometryCollection\") o.geometries.forEach(geometry);\n\t    else if (o.type in geometryType) geom = o, geometryType[o.type](o.arcs);\n\t  }\n\t\n\t  if (arguments.length > 1) {\n\t    var geomsByArc = [],\n\t        geom;\n\t\n\t    var geometryType = {\n\t      LineString: line,\n\t      MultiLineString: polygon,\n\t      Polygon: polygon,\n\t      MultiPolygon: function(arcs) { arcs.forEach(polygon); }\n\t    };\n\t\n\t    geometry(o);\n\t\n\t    geomsByArc.forEach(arguments.length < 3\n\t        ? function(geoms) { arcs.push(geoms[0].i); }\n\t        : function(geoms) { if (filter(geoms[0].g, geoms[geoms.length - 1].g)) arcs.push(geoms[0].i); });\n\t  } else {\n\t    for (var i = 0, n = topology.arcs.length; i < n; ++i) arcs.push(i);\n\t  }\n\t\n\t  return {type: \"MultiLineString\", arcs: stitchArcs(topology, arcs)};\n\t}\n\t\n\tfunction cartesianTriangleArea(triangle) {\n\t  var a = triangle[0], b = triangle[1], c = triangle[2];\n\t  return Math.abs((a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]));\n\t}\n\t\n\tfunction ring(ring) {\n\t  var i = -1,\n\t      n = ring.length,\n\t      a,\n\t      b = ring[n - 1],\n\t      area = 0;\n\t\n\t  while (++i < n) {\n\t    a = b;\n\t    b = ring[i];\n\t    area += a[0] * b[1] - a[1] * b[0];\n\t  }\n\t\n\t  return area / 2;\n\t}\n\t\n\tfunction merge(topology) {\n\t  return object(topology, mergeArcs.apply(this, arguments));\n\t}\n\t\n\tfunction mergeArcs(topology, objects) {\n\t  var polygonsByArc = {},\n\t      polygons = [],\n\t      components = [];\n\t\n\t  objects.forEach(function(o) {\n\t    if (o.type === \"Polygon\") register(o.arcs);\n\t    else if (o.type === \"MultiPolygon\") o.arcs.forEach(register);\n\t  });\n\t\n\t  function register(polygon) {\n\t    polygon.forEach(function(ring$$) {\n\t      ring$$.forEach(function(arc) {\n\t        (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon);\n\t      });\n\t    });\n\t    polygons.push(polygon);\n\t  }\n\t\n\t  function area(ring$$) {\n\t    return Math.abs(ring(object(topology, {type: \"Polygon\", arcs: [ring$$]}).coordinates[0]));\n\t  }\n\t\n\t  polygons.forEach(function(polygon) {\n\t    if (!polygon._) {\n\t      var component = [],\n\t          neighbors = [polygon];\n\t      polygon._ = 1;\n\t      components.push(component);\n\t      while (polygon = neighbors.pop()) {\n\t        component.push(polygon);\n\t        polygon.forEach(function(ring$$) {\n\t          ring$$.forEach(function(arc) {\n\t            polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon) {\n\t              if (!polygon._) {\n\t                polygon._ = 1;\n\t                neighbors.push(polygon);\n\t              }\n\t            });\n\t          });\n\t        });\n\t      }\n\t    }\n\t  });\n\t\n\t  polygons.forEach(function(polygon) {\n\t    delete polygon._;\n\t  });\n\t\n\t  return {\n\t    type: \"MultiPolygon\",\n\t    arcs: components.map(function(polygons) {\n\t      var arcs = [], n;\n\t\n\t      // Extract the exterior (unique) arcs.\n\t      polygons.forEach(function(polygon) {\n\t        polygon.forEach(function(ring$$) {\n\t          ring$$.forEach(function(arc) {\n\t            if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {\n\t              arcs.push(arc);\n\t            }\n\t          });\n\t        });\n\t      });\n\t\n\t      // Stitch the arcs into one or more rings.\n\t      arcs = stitchArcs(topology, arcs);\n\t\n\t      // If more than one ring is returned,\n\t      // at most one of these rings can be the exterior;\n\t      // choose the one with the greatest absolute area.\n\t      if ((n = arcs.length) > 1) {\n\t        for (var i = 1, k = area(arcs[0]), ki, t; i < n; ++i) {\n\t          if ((ki = area(arcs[i])) > k) {\n\t            t = arcs[0], arcs[0] = arcs[i], arcs[i] = t, k = ki;\n\t          }\n\t        }\n\t      }\n\t\n\t      return arcs;\n\t    })\n\t  };\n\t}\n\t\n\tfunction neighbors(objects) {\n\t  var indexesByArc = {}, // arc index -> array of object indexes\n\t      neighbors = objects.map(function() { return []; });\n\t\n\t  function line(arcs, i) {\n\t    arcs.forEach(function(a) {\n\t      if (a < 0) a = ~a;\n\t      var o = indexesByArc[a];\n\t      if (o) o.push(i);\n\t      else indexesByArc[a] = [i];\n\t    });\n\t  }\n\t\n\t  function polygon(arcs, i) {\n\t    arcs.forEach(function(arc) { line(arc, i); });\n\t  }\n\t\n\t  function geometry(o, i) {\n\t    if (o.type === \"GeometryCollection\") o.geometries.forEach(function(o) { geometry(o, i); });\n\t    else if (o.type in geometryType) geometryType[o.type](o.arcs, i);\n\t  }\n\t\n\t  var geometryType = {\n\t    LineString: line,\n\t    MultiLineString: polygon,\n\t    Polygon: polygon,\n\t    MultiPolygon: function(arcs, i) { arcs.forEach(function(arc) { polygon(arc, i); }); }\n\t  };\n\t\n\t  objects.forEach(geometry);\n\t\n\t  for (var i in indexesByArc) {\n\t    for (var indexes = indexesByArc[i], m = indexes.length, j = 0; j < m; ++j) {\n\t      for (var k = j + 1; k < m; ++k) {\n\t        var ij = indexes[j], ik = indexes[k], n;\n\t        if ((n = neighbors[ij])[i = bisect(n, ik)] !== ik) n.splice(i, 0, ik);\n\t        if ((n = neighbors[ik])[i = bisect(n, ij)] !== ij) n.splice(i, 0, ij);\n\t      }\n\t    }\n\t  }\n\t\n\t  return neighbors;\n\t}\n\t\n\tfunction compareArea(a, b) {\n\t  return a[1][2] - b[1][2];\n\t}\n\t\n\tfunction minAreaHeap() {\n\t  var heap = {},\n\t      array = [],\n\t      size = 0;\n\t\n\t  heap.push = function(object) {\n\t    up(array[object._ = size] = object, size++);\n\t    return size;\n\t  };\n\t\n\t  heap.pop = function() {\n\t    if (size <= 0) return;\n\t    var removed = array[0], object;\n\t    if (--size > 0) object = array[size], down(array[object._ = 0] = object, 0);\n\t    return removed;\n\t  };\n\t\n\t  heap.remove = function(removed) {\n\t    var i = removed._, object;\n\t    if (array[i] !== removed) return; // invalid request\n\t    if (i !== --size) object = array[size], (compareArea(object, removed) < 0 ? up : down)(array[object._ = i] = object, i);\n\t    return i;\n\t  };\n\t\n\t  function up(object, i) {\n\t    while (i > 0) {\n\t      var j = ((i + 1) >> 1) - 1,\n\t          parent = array[j];\n\t      if (compareArea(object, parent) >= 0) break;\n\t      array[parent._ = i] = parent;\n\t      array[object._ = i = j] = object;\n\t    }\n\t  }\n\t\n\t  function down(object, i) {\n\t    while (true) {\n\t      var r = (i + 1) << 1,\n\t          l = r - 1,\n\t          j = i,\n\t          child = array[j];\n\t      if (l < size && compareArea(array[l], child) < 0) child = array[j = l];\n\t      if (r < size && compareArea(array[r], child) < 0) child = array[j = r];\n\t      if (j === i) break;\n\t      array[child._ = i] = child;\n\t      array[object._ = i = j] = object;\n\t    }\n\t  }\n\t\n\t  return heap;\n\t}\n\t\n\tfunction presimplify(topology, triangleArea) {\n\t  var absolute = transformAbsolute(topology.transform),\n\t      relative = transformRelative(topology.transform),\n\t      heap = minAreaHeap();\n\t\n\t  if (!triangleArea) triangleArea = cartesianTriangleArea;\n\t\n\t  topology.arcs.forEach(function(arc) {\n\t    var triangles = [],\n\t        maxArea = 0,\n\t        triangle,\n\t        i,\n\t        n,\n\t        p;\n\t\n\t    // To store each point’s effective area, we create a new array rather than\n\t    // extending the passed-in point to workaround a Chrome/V8 bug (getting\n\t    // stuck in smi mode). For midpoints, the initial effective area of\n\t    // Infinity will be computed in the next step.\n\t    for (i = 0, n = arc.length; i < n; ++i) {\n\t      p = arc[i];\n\t      absolute(arc[i] = [p[0], p[1], Infinity], i);\n\t    }\n\t\n\t    for (i = 1, n = arc.length - 1; i < n; ++i) {\n\t      triangle = arc.slice(i - 1, i + 2);\n\t      triangle[1][2] = triangleArea(triangle);\n\t      triangles.push(triangle);\n\t      heap.push(triangle);\n\t    }\n\t\n\t    for (i = 0, n = triangles.length; i < n; ++i) {\n\t      triangle = triangles[i];\n\t      triangle.previous = triangles[i - 1];\n\t      triangle.next = triangles[i + 1];\n\t    }\n\t\n\t    while (triangle = heap.pop()) {\n\t      var previous = triangle.previous,\n\t          next = triangle.next;\n\t\n\t      // If the area of the current point is less than that of the previous point\n\t      // to be eliminated, use the latter's area instead. This ensures that the\n\t      // current point cannot be eliminated without eliminating previously-\n\t      // eliminated points.\n\t      if (triangle[1][2] < maxArea) triangle[1][2] = maxArea;\n\t      else maxArea = triangle[1][2];\n\t\n\t      if (previous) {\n\t        previous.next = next;\n\t        previous[2] = triangle[2];\n\t        update(previous);\n\t      }\n\t\n\t      if (next) {\n\t        next.previous = previous;\n\t        next[0] = triangle[0];\n\t        update(next);\n\t      }\n\t    }\n\t\n\t    arc.forEach(relative);\n\t  });\n\t\n\t  function update(triangle) {\n\t    heap.remove(triangle);\n\t    triangle[1][2] = triangleArea(triangle);\n\t    heap.push(triangle);\n\t  }\n\t\n\t  return topology;\n\t}\n\t\n\tvar version = \"1.6.27\";\n\t\n\texports.version = version;\n\texports.mesh = mesh;\n\texports.meshArcs = meshArcs;\n\texports.merge = merge;\n\texports.mergeArcs = mergeArcs;\n\texports.feature = feature;\n\texports.neighbors = neighbors;\n\texports.presimplify = presimplify;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n/***/ },\n/* 27 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar normalize = __webpack_require__(28);\n\t\n\tmodule.exports = function(inputs) {\n\t    return {\n\t        type: 'FeatureCollection',\n\t        features: inputs.reduce(function(memo, input) {\n\t            return memo.concat(normalize(input).features);\n\t        }, [])\n\t    };\n\t};\n\n\n/***/ },\n/* 28 */\n/***/ function(module, exports) {\n\n\tmodule.exports = normalize;\n\t\n\tvar types = {\n\t    Point: 'geometry',\n\t    MultiPoint: 'geometry',\n\t    LineString: 'geometry',\n\t    MultiLineString: 'geometry',\n\t    Polygon: 'geometry',\n\t    MultiPolygon: 'geometry',\n\t    GeometryCollection: 'geometry',\n\t    Feature: 'feature',\n\t    FeatureCollection: 'featurecollection'\n\t};\n\t\n\t/**\n\t * Normalize a GeoJSON feature into a FeatureCollection.\n\t *\n\t * @param {object} gj geojson data\n\t * @returns {object} normalized geojson data\n\t */\n\tfunction normalize(gj) {\n\t    if (!gj || !gj.type) return null;\n\t    var type = types[gj.type];\n\t    if (!type) return null;\n\t\n\t    if (type === 'geometry') {\n\t        return {\n\t            type: 'FeatureCollection',\n\t            features: [{\n\t                type: 'Feature',\n\t                properties: {},\n\t                geometry: gj\n\t            }]\n\t        };\n\t    } else if (type === 'feature') {\n\t        return {\n\t            type: 'FeatureCollection',\n\t            features: [gj]\n\t        };\n\t    } else if (type === 'featurecollection') {\n\t        return gj;\n\t    }\n\t}\n\n\n/***/ },\n/* 29 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tmodule.exports = earcut;\n\t\n\tfunction earcut(data, holeIndices, dim) {\n\t\n\t    dim = dim || 2;\n\t\n\t    var hasHoles = holeIndices && holeIndices.length,\n\t        outerLen = hasHoles ? holeIndices[0] * dim : data.length,\n\t        outerNode = linkedList(data, 0, outerLen, dim, true),\n\t        triangles = [];\n\t\n\t    if (!outerNode) return triangles;\n\t\n\t    var minX, minY, maxX, maxY, x, y, size;\n\t\n\t    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);\n\t\n\t    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox\n\t    if (data.length > 80 * dim) {\n\t        minX = maxX = data[0];\n\t        minY = maxY = data[1];\n\t\n\t        for (var i = dim; i < outerLen; i += dim) {\n\t            x = data[i];\n\t            y = data[i + 1];\n\t            if (x < minX) minX = x;\n\t            if (y < minY) minY = y;\n\t            if (x > maxX) maxX = x;\n\t            if (y > maxY) maxY = y;\n\t        }\n\t\n\t        // minX, minY and size are later used to transform coords into integers for z-order calculation\n\t        size = Math.max(maxX - minX, maxY - minY);\n\t    }\n\t\n\t    earcutLinked(outerNode, triangles, dim, minX, minY, size);\n\t\n\t    return triangles;\n\t}\n\t\n\t// create a circular doubly linked list from polygon points in the specified winding order\n\tfunction linkedList(data, start, end, dim, clockwise) {\n\t    var i, last;\n\t\n\t    if (clockwise === (signedArea(data, start, end, dim) > 0)) {\n\t        for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);\n\t    } else {\n\t        for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);\n\t    }\n\t\n\t    if (last && equals(last, last.next)) {\n\t        removeNode(last);\n\t        last = last.next;\n\t    }\n\t\n\t    return last;\n\t}\n\t\n\t// eliminate colinear or duplicate points\n\tfunction filterPoints(start, end) {\n\t    if (!start) return start;\n\t    if (!end) end = start;\n\t\n\t    var p = start,\n\t        again;\n\t    do {\n\t        again = false;\n\t\n\t        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {\n\t            removeNode(p);\n\t            p = end = p.prev;\n\t            if (p === p.next) return null;\n\t            again = true;\n\t\n\t        } else {\n\t            p = p.next;\n\t        }\n\t    } while (again || p !== end);\n\t\n\t    return end;\n\t}\n\t\n\t// main ear slicing loop which triangulates a polygon (given as a linked list)\n\tfunction earcutLinked(ear, triangles, dim, minX, minY, size, pass) {\n\t    if (!ear) return;\n\t\n\t    // interlink polygon nodes in z-order\n\t    if (!pass && size) indexCurve(ear, minX, minY, size);\n\t\n\t    var stop = ear,\n\t        prev, next;\n\t\n\t    // iterate through ears, slicing them one by one\n\t    while (ear.prev !== ear.next) {\n\t        prev = ear.prev;\n\t        next = ear.next;\n\t\n\t        if (size ? isEarHashed(ear, minX, minY, size) : isEar(ear)) {\n\t            // cut off the triangle\n\t            triangles.push(prev.i / dim);\n\t            triangles.push(ear.i / dim);\n\t            triangles.push(next.i / dim);\n\t\n\t            removeNode(ear);\n\t\n\t            // skipping the next vertice leads to less sliver triangles\n\t            ear = next.next;\n\t            stop = next.next;\n\t\n\t            continue;\n\t        }\n\t\n\t        ear = next;\n\t\n\t        // if we looped through the whole remaining polygon and can't find any more ears\n\t        if (ear === stop) {\n\t            // try filtering points and slicing again\n\t            if (!pass) {\n\t                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, size, 1);\n\t\n\t            // if this didn't work, try curing all small self-intersections locally\n\t            } else if (pass === 1) {\n\t                ear = cureLocalIntersections(ear, triangles, dim);\n\t                earcutLinked(ear, triangles, dim, minX, minY, size, 2);\n\t\n\t            // as a last resort, try splitting the remaining polygon into two\n\t            } else if (pass === 2) {\n\t                splitEarcut(ear, triangles, dim, minX, minY, size);\n\t            }\n\t\n\t            break;\n\t        }\n\t    }\n\t}\n\t\n\t// check whether a polygon node forms a valid ear with adjacent nodes\n\tfunction isEar(ear) {\n\t    var a = ear.prev,\n\t        b = ear,\n\t        c = ear.next;\n\t\n\t    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear\n\t\n\t    // now make sure we don't have other points inside the potential ear\n\t    var p = ear.next.next;\n\t\n\t    while (p !== ear.prev) {\n\t        if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&\n\t            area(p.prev, p, p.next) >= 0) return false;\n\t        p = p.next;\n\t    }\n\t\n\t    return true;\n\t}\n\t\n\tfunction isEarHashed(ear, minX, minY, size) {\n\t    var a = ear.prev,\n\t        b = ear,\n\t        c = ear.next;\n\t\n\t    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear\n\t\n\t    // triangle bbox; min & max are calculated like this for speed\n\t    var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x),\n\t        minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y),\n\t        maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x),\n\t        maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y);\n\t\n\t    // z-order range for the current triangle bbox;\n\t    var minZ = zOrder(minTX, minTY, minX, minY, size),\n\t        maxZ = zOrder(maxTX, maxTY, minX, minY, size);\n\t\n\t    // first look for points inside the triangle in increasing z-order\n\t    var p = ear.nextZ;\n\t\n\t    while (p && p.z <= maxZ) {\n\t        if (p !== ear.prev && p !== ear.next &&\n\t            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&\n\t            area(p.prev, p, p.next) >= 0) return false;\n\t        p = p.nextZ;\n\t    }\n\t\n\t    // then look for points in decreasing z-order\n\t    p = ear.prevZ;\n\t\n\t    while (p && p.z >= minZ) {\n\t        if (p !== ear.prev && p !== ear.next &&\n\t            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&\n\t            area(p.prev, p, p.next) >= 0) return false;\n\t        p = p.prevZ;\n\t    }\n\t\n\t    return true;\n\t}\n\t\n\t// go through all polygon nodes and cure small local self-intersections\n\tfunction cureLocalIntersections(start, triangles, dim) {\n\t    var p = start;\n\t    do {\n\t        var a = p.prev,\n\t            b = p.next.next;\n\t\n\t        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {\n\t\n\t            triangles.push(a.i / dim);\n\t            triangles.push(p.i / dim);\n\t            triangles.push(b.i / dim);\n\t\n\t            // remove two nodes involved\n\t            removeNode(p);\n\t            removeNode(p.next);\n\t\n\t            p = start = b;\n\t        }\n\t        p = p.next;\n\t    } while (p !== start);\n\t\n\t    return p;\n\t}\n\t\n\t// try splitting polygon into two and triangulate them independently\n\tfunction splitEarcut(start, triangles, dim, minX, minY, size) {\n\t    // look for a valid diagonal that divides the polygon into two\n\t    var a = start;\n\t    do {\n\t        var b = a.next.next;\n\t        while (b !== a.prev) {\n\t            if (a.i !== b.i && isValidDiagonal(a, b)) {\n\t                // split the polygon in two by the diagonal\n\t                var c = splitPolygon(a, b);\n\t\n\t                // filter colinear points around the cuts\n\t                a = filterPoints(a, a.next);\n\t                c = filterPoints(c, c.next);\n\t\n\t                // run earcut on each half\n\t                earcutLinked(a, triangles, dim, minX, minY, size);\n\t                earcutLinked(c, triangles, dim, minX, minY, size);\n\t                return;\n\t            }\n\t            b = b.next;\n\t        }\n\t        a = a.next;\n\t    } while (a !== start);\n\t}\n\t\n\t// link every hole into the outer loop, producing a single-ring polygon without holes\n\tfunction eliminateHoles(data, holeIndices, outerNode, dim) {\n\t    var queue = [],\n\t        i, len, start, end, list;\n\t\n\t    for (i = 0, len = holeIndices.length; i < len; i++) {\n\t        start = holeIndices[i] * dim;\n\t        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;\n\t        list = linkedList(data, start, end, dim, false);\n\t        if (list === list.next) list.steiner = true;\n\t        queue.push(getLeftmost(list));\n\t    }\n\t\n\t    queue.sort(compareX);\n\t\n\t    // process holes from left to right\n\t    for (i = 0; i < queue.length; i++) {\n\t        eliminateHole(queue[i], outerNode);\n\t        outerNode = filterPoints(outerNode, outerNode.next);\n\t    }\n\t\n\t    return outerNode;\n\t}\n\t\n\tfunction compareX(a, b) {\n\t    return a.x - b.x;\n\t}\n\t\n\t// find a bridge between vertices that connects hole with an outer ring and and link it\n\tfunction eliminateHole(hole, outerNode) {\n\t    outerNode = findHoleBridge(hole, outerNode);\n\t    if (outerNode) {\n\t        var b = splitPolygon(outerNode, hole);\n\t        filterPoints(b, b.next);\n\t    }\n\t}\n\t\n\t// David Eberly's algorithm for finding a bridge between hole and outer polygon\n\tfunction findHoleBridge(hole, outerNode) {\n\t    var p = outerNode,\n\t        hx = hole.x,\n\t        hy = hole.y,\n\t        qx = -Infinity,\n\t        m;\n\t\n\t    // find a segment intersected by a ray from the hole's leftmost point to the left;\n\t    // segment's endpoint with lesser x will be potential connection point\n\t    do {\n\t        if (hy <= p.y && hy >= p.next.y) {\n\t            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);\n\t            if (x <= hx && x > qx) {\n\t                qx = x;\n\t                if (x === hx) {\n\t                    if (hy === p.y) return p;\n\t                    if (hy === p.next.y) return p.next;\n\t                }\n\t                m = p.x < p.next.x ? p : p.next;\n\t            }\n\t        }\n\t        p = p.next;\n\t    } while (p !== outerNode);\n\t\n\t    if (!m) return null;\n\t\n\t    if (hx === qx) return m.prev; // hole touches outer segment; pick lower endpoint\n\t\n\t    // look for points inside the triangle of hole point, segment intersection and endpoint;\n\t    // if there are no points found, we have a valid connection;\n\t    // otherwise choose the point of the minimum angle with the ray as connection point\n\t\n\t    var stop = m,\n\t        mx = m.x,\n\t        my = m.y,\n\t        tanMin = Infinity,\n\t        tan;\n\t\n\t    p = m.next;\n\t\n\t    while (p !== stop) {\n\t        if (hx >= p.x && p.x >= mx &&\n\t                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {\n\t\n\t            tan = Math.abs(hy - p.y) / (hx - p.x); // tangential\n\t\n\t            if ((tan < tanMin || (tan === tanMin && p.x > m.x)) && locallyInside(p, hole)) {\n\t                m = p;\n\t                tanMin = tan;\n\t            }\n\t        }\n\t\n\t        p = p.next;\n\t    }\n\t\n\t    return m;\n\t}\n\t\n\t// interlink polygon nodes in z-order\n\tfunction indexCurve(start, minX, minY, size) {\n\t    var p = start;\n\t    do {\n\t        if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, size);\n\t        p.prevZ = p.prev;\n\t        p.nextZ = p.next;\n\t        p = p.next;\n\t    } while (p !== start);\n\t\n\t    p.prevZ.nextZ = null;\n\t    p.prevZ = null;\n\t\n\t    sortLinked(p);\n\t}\n\t\n\t// Simon Tatham's linked list merge sort algorithm\n\t// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html\n\tfunction sortLinked(list) {\n\t    var i, p, q, e, tail, numMerges, pSize, qSize,\n\t        inSize = 1;\n\t\n\t    do {\n\t        p = list;\n\t        list = null;\n\t        tail = null;\n\t        numMerges = 0;\n\t\n\t        while (p) {\n\t            numMerges++;\n\t            q = p;\n\t            pSize = 0;\n\t            for (i = 0; i < inSize; i++) {\n\t                pSize++;\n\t                q = q.nextZ;\n\t                if (!q) break;\n\t            }\n\t\n\t            qSize = inSize;\n\t\n\t            while (pSize > 0 || (qSize > 0 && q)) {\n\t\n\t                if (pSize === 0) {\n\t                    e = q;\n\t                    q = q.nextZ;\n\t                    qSize--;\n\t                } else if (qSize === 0 || !q) {\n\t                    e = p;\n\t                    p = p.nextZ;\n\t                    pSize--;\n\t                } else if (p.z <= q.z) {\n\t                    e = p;\n\t                    p = p.nextZ;\n\t                    pSize--;\n\t                } else {\n\t                    e = q;\n\t                    q = q.nextZ;\n\t                    qSize--;\n\t                }\n\t\n\t                if (tail) tail.nextZ = e;\n\t                else list = e;\n\t\n\t                e.prevZ = tail;\n\t                tail = e;\n\t            }\n\t\n\t            p = q;\n\t        }\n\t\n\t        tail.nextZ = null;\n\t        inSize *= 2;\n\t\n\t    } while (numMerges > 1);\n\t\n\t    return list;\n\t}\n\t\n\t// z-order of a point given coords and size of the data bounding box\n\tfunction zOrder(x, y, minX, minY, size) {\n\t    // coords are transformed into non-negative 15-bit integer range\n\t    x = 32767 * (x - minX) / size;\n\t    y = 32767 * (y - minY) / size;\n\t\n\t    x = (x | (x << 8)) & 0x00FF00FF;\n\t    x = (x | (x << 4)) & 0x0F0F0F0F;\n\t    x = (x | (x << 2)) & 0x33333333;\n\t    x = (x | (x << 1)) & 0x55555555;\n\t\n\t    y = (y | (y << 8)) & 0x00FF00FF;\n\t    y = (y | (y << 4)) & 0x0F0F0F0F;\n\t    y = (y | (y << 2)) & 0x33333333;\n\t    y = (y | (y << 1)) & 0x55555555;\n\t\n\t    return x | (y << 1);\n\t}\n\t\n\t// find the leftmost node of a polygon ring\n\tfunction getLeftmost(start) {\n\t    var p = start,\n\t        leftmost = start;\n\t    do {\n\t        if (p.x < leftmost.x) leftmost = p;\n\t        p = p.next;\n\t    } while (p !== start);\n\t\n\t    return leftmost;\n\t}\n\t\n\t// check if a point lies within a convex triangle\n\tfunction pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {\n\t    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&\n\t           (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&\n\t           (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;\n\t}\n\t\n\t// check if a diagonal between two polygon nodes is valid (lies in polygon interior)\n\tfunction isValidDiagonal(a, b) {\n\t    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) &&\n\t           locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);\n\t}\n\t\n\t// signed area of a triangle\n\tfunction area(p, q, r) {\n\t    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);\n\t}\n\t\n\t// check if two points are equal\n\tfunction equals(p1, p2) {\n\t    return p1.x === p2.x && p1.y === p2.y;\n\t}\n\t\n\t// check if two segments intersect\n\tfunction intersects(p1, q1, p2, q2) {\n\t    if ((equals(p1, q1) && equals(p2, q2)) ||\n\t        (equals(p1, q2) && equals(p2, q1))) return true;\n\t    return area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 &&\n\t           area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0;\n\t}\n\t\n\t// check if a polygon diagonal intersects any polygon segments\n\tfunction intersectsPolygon(a, b) {\n\t    var p = a;\n\t    do {\n\t        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&\n\t                intersects(p, p.next, a, b)) return true;\n\t        p = p.next;\n\t    } while (p !== a);\n\t\n\t    return false;\n\t}\n\t\n\t// check if a polygon diagonal is locally inside the polygon\n\tfunction locallyInside(a, b) {\n\t    return area(a.prev, a, a.next) < 0 ?\n\t        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :\n\t        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;\n\t}\n\t\n\t// check if the middle point of a polygon diagonal is inside the polygon\n\tfunction middleInside(a, b) {\n\t    var p = a,\n\t        inside = false,\n\t        px = (a.x + b.x) / 2,\n\t        py = (a.y + b.y) / 2;\n\t    do {\n\t        if (((p.y > py) !== (p.next.y > py)) && (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))\n\t            inside = !inside;\n\t        p = p.next;\n\t    } while (p !== a);\n\t\n\t    return inside;\n\t}\n\t\n\t// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;\n\t// if one belongs to the outer ring and another to a hole, it merges it into a single ring\n\tfunction splitPolygon(a, b) {\n\t    var a2 = new Node(a.i, a.x, a.y),\n\t        b2 = new Node(b.i, b.x, b.y),\n\t        an = a.next,\n\t        bp = b.prev;\n\t\n\t    a.next = b;\n\t    b.prev = a;\n\t\n\t    a2.next = an;\n\t    an.prev = a2;\n\t\n\t    b2.next = a2;\n\t    a2.prev = b2;\n\t\n\t    bp.next = b2;\n\t    b2.prev = bp;\n\t\n\t    return b2;\n\t}\n\t\n\t// create a node and optionally link it with previous one (in a circular doubly linked list)\n\tfunction insertNode(i, x, y, last) {\n\t    var p = new Node(i, x, y);\n\t\n\t    if (!last) {\n\t        p.prev = p;\n\t        p.next = p;\n\t\n\t    } else {\n\t        p.next = last.next;\n\t        p.prev = last;\n\t        last.next.prev = p;\n\t        last.next = p;\n\t    }\n\t    return p;\n\t}\n\t\n\tfunction removeNode(p) {\n\t    p.next.prev = p.prev;\n\t    p.prev.next = p.next;\n\t\n\t    if (p.prevZ) p.prevZ.nextZ = p.nextZ;\n\t    if (p.nextZ) p.nextZ.prevZ = p.prevZ;\n\t}\n\t\n\tfunction Node(i, x, y) {\n\t    // vertice index in coordinates array\n\t    this.i = i;\n\t\n\t    // vertex coordinates\n\t    this.x = x;\n\t    this.y = y;\n\t\n\t    // previous and next vertice nodes in a polygon ring\n\t    this.prev = null;\n\t    this.next = null;\n\t\n\t    // z-order curve value\n\t    this.z = null;\n\t\n\t    // previous and next nodes in z-order\n\t    this.prevZ = null;\n\t    this.nextZ = null;\n\t\n\t    // indicates whether this is a steiner point\n\t    this.steiner = false;\n\t}\n\t\n\t// return a percentage difference between the polygon area and its triangulation area;\n\t// used to verify correctness of triangulation\n\tearcut.deviation = function (data, holeIndices, dim, triangles) {\n\t    var hasHoles = holeIndices && holeIndices.length;\n\t    var outerLen = hasHoles ? holeIndices[0] * dim : data.length;\n\t\n\t    var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));\n\t    if (hasHoles) {\n\t        for (var i = 0, len = holeIndices.length; i < len; i++) {\n\t            var start = holeIndices[i] * dim;\n\t            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;\n\t            polygonArea -= Math.abs(signedArea(data, start, end, dim));\n\t        }\n\t    }\n\t\n\t    var trianglesArea = 0;\n\t    for (i = 0; i < triangles.length; i += 3) {\n\t        var a = triangles[i] * dim;\n\t        var b = triangles[i + 1] * dim;\n\t        var c = triangles[i + 2] * dim;\n\t        trianglesArea += Math.abs(\n\t            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -\n\t            (data[a] - data[b]) * (data[c + 1] - data[a + 1]));\n\t    }\n\t\n\t    return polygonArea === 0 && trianglesArea === 0 ? 0 :\n\t        Math.abs((trianglesArea - polygonArea) / polygonArea);\n\t};\n\t\n\tfunction signedArea(data, start, end, dim) {\n\t    var sum = 0;\n\t    for (var i = start, j = end - dim; i < end; i += dim) {\n\t        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);\n\t        j = i;\n\t    }\n\t    return sum;\n\t}\n\t\n\t// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts\n\tearcut.flatten = function (data) {\n\t    var dim = data[0][0].length,\n\t        result = {vertices: [], holes: [], dimensions: dim},\n\t        holeIndex = 0;\n\t\n\t    for (var i = 0; i < data.length; i++) {\n\t        for (var j = 0; j < data[i].length; j++) {\n\t            for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);\n\t        }\n\t        if (i > 0) {\n\t            holeIndex += data[i - 1].length;\n\t            result.holes.push(holeIndex);\n\t        }\n\t    }\n\t    return result;\n\t};\n\n\n/***/ },\n/* 30 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t/*\n\t * Extrude a polygon given its vertices and triangulated faces\n\t *\n\t * Based on:\n\t * https://github.com/freeman-lab/extrude\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(6);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar extrudePolygon = function extrudePolygon(points, faces, _options) {\n\t  var defaults = {\n\t    top: 1,\n\t    bottom: 0,\n\t    closed: true\n\t  };\n\t\n\t  var options = (0, _lodashAssign2['default'])({}, defaults, _options);\n\t\n\t  var n = points.length;\n\t  var positions;\n\t  var cells;\n\t  var topCells;\n\t  var bottomCells;\n\t  var sideCells;\n\t\n\t  // If bottom and top values are identical then return the flat shape\n\t  options.top === options.bottom ? flat() : full();\n\t\n\t  function flat() {\n\t    positions = points.map(function (p) {\n\t      return [p[0], options.top, p[1]];\n\t    });\n\t    cells = faces;\n\t    topCells = faces;\n\t  }\n\t\n\t  function full() {\n\t    positions = [];\n\t    points.forEach(function (p) {\n\t      positions.push([p[0], options.top, p[1]]);\n\t    });\n\t    points.forEach(function (p) {\n\t      positions.push([p[0], options.bottom, p[1]]);\n\t    });\n\t\n\t    cells = [];\n\t    for (var i = 0; i < n; i++) {\n\t      if (i === n - 1) {\n\t        cells.push([i + n, n, i]);\n\t        cells.push([0, i, n]);\n\t      } else {\n\t        cells.push([i + n, i + n + 1, i]);\n\t        cells.push([i + 1, i, i + n + 1]);\n\t      }\n\t    }\n\t\n\t    sideCells = [].concat(cells);\n\t\n\t    if (options.closed) {\n\t      var top = faces;\n\t      var bottom = top.map(function (p) {\n\t        return p.map(function (v) {\n\t          return v + n;\n\t        });\n\t      });\n\t      bottom = bottom.map(function (p) {\n\t        return [p[0], p[2], p[1]];\n\t      });\n\t      cells = cells.concat(top).concat(bottom);\n\t\n\t      topCells = top;\n\t      bottomCells = bottom;\n\t    }\n\t  }\n\t\n\t  return {\n\t    positions: positions,\n\t    faces: cells,\n\t    top: topCells,\n\t    bottom: bottomCells,\n\t    sides: sideCells\n\t  };\n\t};\n\t\n\texports['default'] = extrudePolygon;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 31 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _WorkerPool = __webpack_require__(32);\n\t\n\tvar _WorkerPool2 = _interopRequireDefault(_WorkerPool);\n\t\n\tvar Worker = (function () {\n\t  var _maxWorkers = 2;\n\t  var pool;\n\t\n\t  var createWorkers = function createWorkers(maxWorkers, workerScript) {\n\t    pool = new _WorkerPool2['default']({\n\t      numThreads: maxWorkers ? maxWorkers : _maxWorkers,\n\t      workerScript: workerScript ? workerScript : 'vizicities-worker.js'\n\t    });\n\t\n\t    return pool.createWorkers();\n\t  };\n\t\n\t  var exec = function exec(method, args, transferrables) {\n\t    return pool.exec(method, args, transferrables);\n\t  };\n\t\n\t  return {\n\t    createWorkers: createWorkers,\n\t    exec: exec\n\t  };\n\t})();\n\t\n\texports['default'] = Worker;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 32 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tvar _WorkerPoolWorker = __webpack_require__(33);\n\t\n\tvar _WorkerPoolWorker2 = _interopRequireDefault(_WorkerPoolWorker);\n\t\n\tvar DEBUG = false;\n\t\n\tvar WorkerPool = (function () {\n\t  function WorkerPool(options) {\n\t    _classCallCheck(this, WorkerPool);\n\t\n\t    this.numThreads = options.numThreads || 2;\n\t    this.workerScript = options.workerScript;\n\t\n\t    this.workers = [];\n\t    this.tasks = [];\n\t  }\n\t\n\t  _createClass(WorkerPool, [{\n\t    key: 'createWorkers',\n\t    value: function createWorkers() {\n\t      var _this = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        var workerPromises = [];\n\t\n\t        for (var i = 0; i < _this.numThreads; i++) {\n\t          workerPromises.push(_this.createWorker());\n\t        }\n\t\n\t        Promise.all(workerPromises).then(function () {\n\t          if (DEBUG) {\n\t            console.log('All workers ready', performance.now());\n\t          }\n\t          resolve();\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'createWorker',\n\t    value: function createWorker() {\n\t      var _this2 = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        // Initialise worker\n\t        var worker = new _WorkerPoolWorker2['default']({\n\t          workerScript: _this2.workerScript\n\t        });\n\t\n\t        // Start worker and wait for it to be ready\n\t        return worker.start().then(function () {\n\t          if (DEBUG) {\n\t            console.log('Worker ready', performance.now());\n\t          }\n\t\n\t          // Add worker to pool\n\t          _this2.workers.push(worker);\n\t\n\t          resolve();\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'getFreeWorker',\n\t    value: function getFreeWorker() {\n\t      return this.workers.find(function (worker) {\n\t        return !worker.busy;\n\t      });\n\t    }\n\t\n\t    // Execute task on a worker\n\t  }, {\n\t    key: 'exec',\n\t    value: function exec(method, args, transferrables) {\n\t      var deferred = Promise.deferred();\n\t\n\t      // Create task\n\t      var task = {\n\t        method: method,\n\t        args: args,\n\t        transferrables: transferrables,\n\t        deferred: deferred\n\t      };\n\t\n\t      // Add task to queue\n\t      this.tasks.push(task);\n\t\n\t      // Trigger task processing\n\t      this.processTasks();\n\t\n\t      // Return task promise\n\t      return task.deferred.promise;\n\t    }\n\t  }, {\n\t    key: 'processTasks',\n\t    value: function processTasks() {\n\t      var _this3 = this;\n\t\n\t      if (DEBUG) {\n\t        console.log('Processing tasks');\n\t      }\n\t\n\t      if (this.tasks.length === 0) {\n\t        return;\n\t      }\n\t\n\t      // Find free worker\n\t      var worker = this.getFreeWorker();\n\t\n\t      if (!worker) {\n\t        if (DEBUG) {\n\t          console.log('No workers free');\n\t        }\n\t        return;\n\t      }\n\t\n\t      // Get oldest task\n\t      var task = this.tasks.shift();\n\t\n\t      // Execute task on worker\n\t      worker.exec(task.method, task.args, task.transferrables).then(function (result) {\n\t        // Trigger task processing\n\t        _this3.processTasks();\n\t\n\t        // Return result in deferred task promise\n\t        task.deferred.resolve(result);\n\t      });\n\t    }\n\t  }]);\n\t\n\t  return WorkerPool;\n\t})();\n\t\n\texports['default'] = WorkerPool;\n\t\n\t// Quick shim to create deferred native promises\n\tPromise.deferred = function () {\n\t  var result = {};\n\t\n\t  result.promise = new Promise(function (resolve, reject) {\n\t    result.resolve = resolve;\n\t    result.reject = reject;\n\t  });\n\t\n\t  return result;\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 33 */\n/***/ function(module, exports) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tvar DEBUG = false;\n\t\n\tvar WorkerPoolWorker = (function () {\n\t  function WorkerPoolWorker(options) {\n\t    _classCallCheck(this, WorkerPoolWorker);\n\t\n\t    this.workerScript = options.workerScript;\n\t\n\t    this.ready = false;\n\t    this.busy = false;\n\t    this.deferred = null;\n\t  }\n\t\n\t  _createClass(WorkerPoolWorker, [{\n\t    key: 'start',\n\t    value: function start() {\n\t      var _this = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        _this.worker = new Worker(_this.workerScript);\n\t\n\t        var onStartup = function onStartup(event) {\n\t          if (!event.data || event.data.type !== 'startup') {\n\t            reject();\n\t            return;\n\t          }\n\t\n\t          _this.ready = true;\n\t\n\t          // Remove temporary message handler\n\t          _this.worker.removeEventListener('message', onStartup);\n\t\n\t          // Set up listener to respond to normal events now\n\t          _this.worker.addEventListener('message', function (event) {\n\t            _this.onMessage(event);\n\t          });\n\t\n\t          // Resolve once worker is ready\n\t          resolve();\n\t        };\n\t\n\t        // Set up temporary event listener for warmup\n\t        _this.worker.addEventListener('message', onStartup);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'exec',\n\t    value: function exec(method, args, transferrables) {\n\t      if (DEBUG) {\n\t        console.log('Execute', method, args, transferrables);\n\t      }\n\t\n\t      var deferred = Promise.deferred();\n\t\n\t      this.busy = true;\n\t      this.deferred = deferred;\n\t\n\t      this.worker.postMessage({\n\t        method: method,\n\t        args: args\n\t      }, transferrables);\n\t\n\t      return deferred.promise;\n\t    }\n\t  }, {\n\t    key: 'onMessage',\n\t    value: function onMessage(event) {\n\t      console.log('Message received from worker', performance.now());\n\t\n\t      this.busy = false;\n\t\n\t      if (!event.data || event.data.type === 'error' || event.data.type !== 'result') {\n\t        this.deferred.reject(event.data.payload);\n\t        return;\n\t      }\n\t\n\t      this.deferred.resolve(event.data.payload);\n\t    }\n\t  }]);\n\t\n\t  return WorkerPoolWorker;\n\t})();\n\t\n\texports['default'] = WorkerPoolWorker;\n\t\n\t// Quick shim to create deferred native promises\n\tPromise.deferred = function () {\n\t  var result = {};\n\t\n\t  result.promise = new Promise(function (resolve, reject) {\n\t    result.resolve = resolve;\n\t    result.reject = reject;\n\t  });\n\t\n\t  return result;\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 34 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t/*\n\t * BufferGeometry helpers\n\t */\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar Buffer = (function () {\n\t  // Merge TypedArrays of the same type\n\t  // Returns merged array as well as indexes for splitting the array\n\t  var mergeFloat32Arrays = function mergeFloat32Arrays(arrays) {\n\t    var size = 0;\n\t    var map = new Int32Array(arrays.length * 2);\n\t\n\t    var lastIndex = 0;\n\t    var length;\n\t\n\t    // Find size of each array\n\t    arrays.forEach(function (_array, index) {\n\t      length = _array.length;\n\t      size += length;\n\t      map.set([lastIndex, lastIndex + length], index * 2);\n\t      lastIndex += length;\n\t    });\n\t\n\t    // Create a new array of total size\n\t    var mergedArray = new Float32Array(size);\n\t\n\t    // Add each array to the new array\n\t    arrays.forEach(function (_array, index) {\n\t      mergedArray.set(_array, map[index * 2]);\n\t    });\n\t\n\t    return [mergedArray, map];\n\t  };\n\t\n\t  var splitFloat32Array = function splitFloat32Array(data) {\n\t    var arr = data[0];\n\t    var map = data[1];\n\t\n\t    var start;\n\t    var arrays = [];\n\t\n\t    // Iterate over map\n\t    for (var i = 0; i < map.length / 2; i++) {\n\t      start = i * 2;\n\t      arrays.push(arr.subarray(map[start], map[start + 1]));\n\t    }\n\t\n\t    return arrays;\n\t  };\n\t\n\t  // TODO: Create a generic method that can work for any typed array\n\t  var mergeUint8Arrays = function mergeUint8Arrays(arrays) {\n\t    var size = 0;\n\t    var map = new Int32Array(arrays.length * 2);\n\t\n\t    var lastIndex = 0;\n\t    var length;\n\t\n\t    // Find size of each array\n\t    arrays.forEach(function (_array, index) {\n\t      length = _array.length;\n\t      size += length;\n\t      map.set([lastIndex, lastIndex + length], index * 2);\n\t      lastIndex += length;\n\t    });\n\t\n\t    // Create a new array of total size\n\t    var mergedArray = new Uint8Array(size);\n\t\n\t    // Add each array to the new array\n\t    arrays.forEach(function (_array, index) {\n\t      mergedArray.set(_array, map[index * 2]);\n\t    });\n\t\n\t    return [mergedArray, map];\n\t  };\n\t\n\t  // TODO: Dedupe with splitFloat32Array\n\t  var splitUint8Array = function splitUint8Array(data) {\n\t    var arr = data[0];\n\t    var map = data[1];\n\t\n\t    var start;\n\t    var arrays = [];\n\t\n\t    // Iterate over map\n\t    for (var i = 0; i < map.length / 2; i++) {\n\t      start = i * 2;\n\t      arrays.push(arr.subarray(map[start], map[start + 1]));\n\t    }\n\t\n\t    return arrays;\n\t  };\n\t\n\t  // Merge multiple attribute objects into a single attribute object\n\t  //\n\t  // Attribute objects must all use the same attribute keys\n\t  var mergeAttributes = function mergeAttributes(attributes) {\n\t    var lengths = {};\n\t\n\t    // Find array lengths\n\t    attributes.forEach(function (_attributes) {\n\t      for (var k in _attributes) {\n\t        if (!lengths[k]) {\n\t          lengths[k] = 0;\n\t        }\n\t\n\t        lengths[k] += _attributes[k].length;\n\t      }\n\t    });\n\t\n\t    var mergedAttributes = {};\n\t\n\t    // Set up arrays to merge into\n\t    for (var k in lengths) {\n\t      mergedAttributes[k] = new Float32Array(lengths[k]);\n\t    }\n\t\n\t    var lastLengths = {};\n\t\n\t    attributes.forEach(function (_attributes) {\n\t      for (var k in _attributes) {\n\t        if (!lastLengths[k]) {\n\t          lastLengths[k] = 0;\n\t        }\n\t\n\t        mergedAttributes[k].set(_attributes[k], lastLengths[k]);\n\t\n\t        lastLengths[k] += _attributes[k].length;\n\t      }\n\t    });\n\t\n\t    return mergedAttributes;\n\t  };\n\t\n\t  var createLineGeometry = function createLineGeometry(lines, offset) {\n\t    var geometry = new _three2['default'].BufferGeometry();\n\t\n\t    var vertices = new Float32Array(lines.verticesCount * 3);\n\t    var colours = new Float32Array(lines.verticesCount * 3);\n\t\n\t    var pickingIds;\n\t    if (lines.pickingIds) {\n\t      // One component per vertex (1)\n\t      pickingIds = new Float32Array(lines.verticesCount);\n\t    }\n\t\n\t    var _vertices;\n\t    var _colour;\n\t    var _pickingId;\n\t\n\t    var lastIndex = 0;\n\t\n\t    for (var i = 0; i < lines.vertices.length; i++) {\n\t      _vertices = lines.vertices[i];\n\t      _colour = lines.colours[i];\n\t\n\t      if (pickingIds) {\n\t        _pickingId = lines.pickingIds[i];\n\t      }\n\t\n\t      for (var j = 0; j < _vertices.length; j++) {\n\t        var ax = _vertices[j][0] + offset.x;\n\t        var ay = _vertices[j][1];\n\t        var az = _vertices[j][2] + offset.y;\n\t\n\t        var c1 = _colour[j];\n\t\n\t        vertices[lastIndex * 3 + 0] = ax;\n\t        vertices[lastIndex * 3 + 1] = ay;\n\t        vertices[lastIndex * 3 + 2] = az;\n\t\n\t        colours[lastIndex * 3 + 0] = c1[0];\n\t        colours[lastIndex * 3 + 1] = c1[1];\n\t        colours[lastIndex * 3 + 2] = c1[2];\n\t\n\t        if (pickingIds) {\n\t          pickingIds[lastIndex] = _pickingId;\n\t        }\n\t\n\t        lastIndex++;\n\t      }\n\t    }\n\t\n\t    // itemSize = 3 because there are 3 values (components) per vertex\n\t    geometry.addAttribute('position', new _three2['default'].BufferAttribute(vertices, 3));\n\t    geometry.addAttribute('color', new _three2['default'].BufferAttribute(colours, 3));\n\t\n\t    if (pickingIds) {\n\t      geometry.addAttribute('pickingId', new _three2['default'].BufferAttribute(pickingIds, 1));\n\t    }\n\t\n\t    geometry.computeBoundingBox();\n\t\n\t    return geometry;\n\t  };\n\t\n\t  // TODO: Make picking IDs optional\n\t  var createGeometry = function createGeometry(attributes, offset) {\n\t    var geometry = new _three2['default'].BufferGeometry();\n\t\n\t    // Three components per vertex per face (3 x 3 = 9)\n\t    var vertices = new Float32Array(attributes.facesCount * 9);\n\t    var normals = new Float32Array(attributes.facesCount * 9);\n\t    var colours = new Float32Array(attributes.facesCount * 9);\n\t\n\t    var pickingIds;\n\t    if (attributes.pickingIds) {\n\t      // One component per vertex per face (1 x 3 = 3)\n\t      pickingIds = new Float32Array(attributes.facesCount * 3);\n\t    }\n\t\n\t    var pA = new _three2['default'].Vector3();\n\t    var pB = new _three2['default'].Vector3();\n\t    var pC = new _three2['default'].Vector3();\n\t\n\t    var cb = new _three2['default'].Vector3();\n\t    var ab = new _three2['default'].Vector3();\n\t\n\t    var index;\n\t    var _faces;\n\t    var _vertices;\n\t    var _colour;\n\t    var _pickingId;\n\t    var lastIndex = 0;\n\t    for (var i = 0; i < attributes.faces.length; i++) {\n\t      _faces = attributes.faces[i];\n\t      _vertices = attributes.vertices[i];\n\t      _colour = attributes.colours[i];\n\t\n\t      if (pickingIds) {\n\t        _pickingId = attributes.pickingIds[i];\n\t      }\n\t\n\t      for (var j = 0; j < _faces.length; j++) {\n\t        // Array of vertex indexes for the face\n\t        index = _faces[j][0];\n\t\n\t        var ax = _vertices[index][0] + offset.x;\n\t        var ay = _vertices[index][1];\n\t        var az = _vertices[index][2] + offset.y;\n\t\n\t        var c1 = _colour[j][0];\n\t\n\t        index = _faces[j][1];\n\t\n\t        var bx = _vertices[index][0] + offset.x;\n\t        var by = _vertices[index][1];\n\t        var bz = _vertices[index][2] + offset.y;\n\t\n\t        var c2 = _colour[j][1];\n\t\n\t        index = _faces[j][2];\n\t\n\t        var cx = _vertices[index][0] + offset.x;\n\t        var cy = _vertices[index][1];\n\t        var cz = _vertices[index][2] + offset.y;\n\t\n\t        var c3 = _colour[j][2];\n\t\n\t        // Flat face normals\n\t        // From: http://threejs.org/examples/webgl_buffergeometry.html\n\t        pA.set(ax, ay, az);\n\t        pB.set(bx, by, bz);\n\t        pC.set(cx, cy, cz);\n\t\n\t        cb.subVectors(pC, pB);\n\t        ab.subVectors(pA, pB);\n\t        cb.cross(ab);\n\t\n\t        cb.normalize();\n\t\n\t        var nx = cb.x;\n\t        var ny = cb.y;\n\t        var nz = cb.z;\n\t\n\t        vertices[lastIndex * 9 + 0] = ax;\n\t        vertices[lastIndex * 9 + 1] = ay;\n\t        vertices[lastIndex * 9 + 2] = az;\n\t\n\t        normals[lastIndex * 9 + 0] = nx;\n\t        normals[lastIndex * 9 + 1] = ny;\n\t        normals[lastIndex * 9 + 2] = nz;\n\t\n\t        colours[lastIndex * 9 + 0] = c1[0];\n\t        colours[lastIndex * 9 + 1] = c1[1];\n\t        colours[lastIndex * 9 + 2] = c1[2];\n\t\n\t        vertices[lastIndex * 9 + 3] = bx;\n\t        vertices[lastIndex * 9 + 4] = by;\n\t        vertices[lastIndex * 9 + 5] = bz;\n\t\n\t        normals[lastIndex * 9 + 3] = nx;\n\t        normals[lastIndex * 9 + 4] = ny;\n\t        normals[lastIndex * 9 + 5] = nz;\n\t\n\t        colours[lastIndex * 9 + 3] = c2[0];\n\t        colours[lastIndex * 9 + 4] = c2[1];\n\t        colours[lastIndex * 9 + 5] = c2[2];\n\t\n\t        vertices[lastIndex * 9 + 6] = cx;\n\t        vertices[lastIndex * 9 + 7] = cy;\n\t        vertices[lastIndex * 9 + 8] = cz;\n\t\n\t        normals[lastIndex * 9 + 6] = nx;\n\t        normals[lastIndex * 9 + 7] = ny;\n\t        normals[lastIndex * 9 + 8] = nz;\n\t\n\t        colours[lastIndex * 9 + 6] = c3[0];\n\t        colours[lastIndex * 9 + 7] = c3[1];\n\t        colours[lastIndex * 9 + 8] = c3[2];\n\t\n\t        if (pickingIds) {\n\t          pickingIds[lastIndex * 3 + 0] = _pickingId;\n\t          pickingIds[lastIndex * 3 + 1] = _pickingId;\n\t          pickingIds[lastIndex * 3 + 2] = _pickingId;\n\t        }\n\t\n\t        lastIndex++;\n\t      }\n\t    }\n\t\n\t    // itemSize = 3 because there are 3 values (components) per vertex\n\t    geometry.addAttribute('position', new _three2['default'].BufferAttribute(vertices, 3));\n\t    geometry.addAttribute('normal', new _three2['default'].BufferAttribute(normals, 3));\n\t    geometry.addAttribute('color', new _three2['default'].BufferAttribute(colours, 3));\n\t\n\t    if (pickingIds) {\n\t      geometry.addAttribute('pickingId', new _three2['default'].BufferAttribute(pickingIds, 1));\n\t    }\n\t\n\t    geometry.computeBoundingBox();\n\t\n\t    return geometry;\n\t  };\n\t\n\t  var textEncoder = new TextEncoder('utf-8');\n\t  var textDecoder = new TextDecoder('utf-8');\n\t\n\t  var stringToUint8Array = function stringToUint8Array(str) {\n\t    return textEncoder.encode(str);\n\t  };\n\t\n\t  var uint8ArrayToString = function uint8ArrayToString(ab) {\n\t    return textDecoder.decode(ab);\n\t  };\n\t\n\t  return {\n\t    mergeFloat32Arrays: mergeFloat32Arrays,\n\t    splitFloat32Array: splitFloat32Array,\n\t    mergeUint8Arrays: mergeUint8Arrays,\n\t    splitUint8Array: splitUint8Array,\n\t    mergeAttributes: mergeAttributes,\n\t    createLineGeometry: createLineGeometry,\n\t    createGeometry: createGeometry,\n\t    stringToUint8Array: stringToUint8Array,\n\t    uint8ArrayToString: uint8ArrayToString\n\t  };\n\t})();\n\t\n\texports['default'] = Buffer;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 35 */\n/***/ function(module, exports) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\tvar Stringify = (function () {\n\t  var functionToString = function functionToString(f) {\n\t    return f.toString();\n\t  };\n\t\n\t  // Based on https://github.com/tangrams/tangram/blob/2a31893c814cf15d5077f87ffa10af20160716b9/src/utils/utils.js#L245\n\t  var stringToFunction = function stringToFunction(str) {\n\t    if (typeof str === 'string' && str.match(/^\\s*function\\s*\\w*\\s*\\([\\s\\S]*\\)\\s*\\{[\\s\\S]*\\}/m) != null) {\n\t      var f;\n\t\n\t      try {\n\t        eval('f = ' + str);\n\t        return f;\n\t      } catch (err) {\n\t        return str;\n\t      }\n\t    }\n\t  };\n\t\n\t  return {\n\t    functionToString: functionToString,\n\t    stringToFunction: stringToFunction\n\t  };\n\t})();\n\t\n\texports['default'] = Stringify;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 36 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tvar _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\t// TODO: Move duplicated logic between geometry layrs into GeometryLayer\n\t\n\t// TODO: Look at ways to drop unneeded references to array buffers, etc to\n\t// reduce memory footprint\n\t\n\t// TODO: Support dynamic updating / hiding / animation of geometry\n\t//\n\t// This could be pretty hard as it's all packed away within BufferGeometry and\n\t// may even be merged by another layer (eg. GeoJSONLayer)\n\t//\n\t// How much control should this layer support? Perhaps a different or custom\n\t// layer would be better suited for animation, for example.\n\t\n\t// TODO: Allow _setBufferAttributes to use a custom function passed in to\n\t// generate a custom mesh\n\t\n\tvar _Layer2 = __webpack_require__(4);\n\t\n\tvar _Layer3 = _interopRequireDefault(_Layer2);\n\t\n\tvar _lodashAssign = __webpack_require__(6);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _geoGeo = __webpack_require__(1);\n\t\n\tvar _geoGeo2 = _interopRequireDefault(_geoGeo);\n\t\n\tvar _geoLatLon = __webpack_require__(2);\n\t\n\tvar _geoPoint = __webpack_require__(3);\n\t\n\tvar _earcut2 = __webpack_require__(29);\n\t\n\tvar _earcut3 = _interopRequireDefault(_earcut2);\n\t\n\tvar _utilExtrudePolygon = __webpack_require__(30);\n\t\n\tvar _utilExtrudePolygon2 = _interopRequireDefault(_utilExtrudePolygon);\n\t\n\tvar _enginePickingMaterial = __webpack_require__(37);\n\t\n\tvar _enginePickingMaterial2 = _interopRequireDefault(_enginePickingMaterial);\n\t\n\tvar _utilBuffer = __webpack_require__(34);\n\t\n\tvar _utilBuffer2 = _interopRequireDefault(_utilBuffer);\n\t\n\tvar PolygonLayer = (function (_Layer) {\n\t  _inherits(PolygonLayer, _Layer);\n\t\n\t  function PolygonLayer(coordinates, options) {\n\t    _classCallCheck(this, PolygonLayer);\n\t\n\t    var defaults = {\n\t      output: true,\n\t      interactive: false,\n\t      // Custom material override\n\t      //\n\t      // TODO: Should this be in the style object?\n\t      polygonMaterial: null,\n\t      onPolygonMesh: null,\n\t      onBufferAttributes: null,\n\t      // This default style is separate to Util.GeoJSON.defaultStyle\n\t      style: {\n\t        color: '#ffffff',\n\t        transparent: false,\n\t        opacity: 1,\n\t        blending: _three2['default'].NormalBlending,\n\t        height: 0\n\t      }\n\t    };\n\t\n\t    var _options = (0, _lodashAssign2['default'])({}, defaults, options);\n\t\n\t    _get(Object.getPrototypeOf(PolygonLayer.prototype), 'constructor', this).call(this, _options);\n\t\n\t    // Return coordinates as array of polygons so it's easy to support\n\t    // MultiPolygon features (a single polygon would be a MultiPolygon with a\n\t    // single polygon in the array)\n\t    this._coordinates = PolygonLayer.isSingle(coordinates) ? [coordinates] : coordinates;\n\t  }\n\t\n\t  _createClass(PolygonLayer, [{\n\t    key: '_onAdd',\n\t    value: function _onAdd(world) {\n\t      var _this = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        _this._setCoordinates();\n\t\n\t        if (_this._options.interactive) {\n\t          // Only add to picking mesh if this layer is controlling output\n\t          //\n\t          // Otherwise, assume another component will eventually add a mesh to\n\t          // the picking scene\n\t          if (_this.isOutput()) {\n\t            _this._pickingMesh = new _three2['default'].Object3D();\n\t            _this.addToPicking(_this._pickingMesh);\n\t          }\n\t\n\t          _this._setPickingId();\n\t          _this._addPickingEvents();\n\t        }\n\t\n\t        PolygonLayer.SetBufferAttributes(_this._projectedCoordinates, _this._options).then(function (result) {\n\t          _this._bufferAttributes = _utilBuffer2['default'].mergeAttributes(result.attributes);\n\t\n\t          if (result.outlineAttributes.length > 0) {\n\t            _this._outlineBufferAttributes = _utilBuffer2['default'].mergeAttributes(result.outlineAttributes);\n\t          }\n\t\n\t          _this._flat = result.flat;\n\t\n\t          if (_this.isOutput()) {\n\t            var attributeLengths = {\n\t              positions: 3,\n\t              normals: 3,\n\t              colors: 3,\n\t              tops: 1\n\t            };\n\t\n\t            if (_this._options.interactive) {\n\t              attributeLengths.pickingIds = 1;\n\t            }\n\t\n\t            var style = _this._options.style;\n\t\n\t            // Set mesh if not merging elsewhere\n\t            PolygonLayer.SetMesh(_this._bufferAttributes, attributeLengths, _this._flat, style, _this._options, _this._world._environment._skybox).then(function (result) {\n\t              // Output mesh\n\t              _this.add(result.mesh);\n\t\n\t              if (result.pickingMesh) {\n\t                _this._pickingMesh.add(result.pickingMesh);\n\t              }\n\t            });\n\t          }\n\t\n\t          result.attributes = null;\n\t          result.outlineAttributes = null;\n\t          result = null;\n\t\n\t          resolve(_this);\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t\n\t    // Return center of polygon as a LatLon\n\t    //\n\t    // This is used for things like placing popups / UI elements on the layer\n\t    //\n\t    // TODO: Find proper center position instead of returning first coordinate\n\t    // SEE: https://github.com/Leaflet/Leaflet/blob/master/src/layer/vector/Polygon.js#L15\n\t  }, {\n\t    key: 'getCenter',\n\t    value: function getCenter() {\n\t      return this._center;\n\t    }\n\t\n\t    // Return polygon bounds in geographic coordinates\n\t    //\n\t    // TODO: Implement getBounds()\n\t  }, {\n\t    key: 'getBounds',\n\t    value: function getBounds() {}\n\t\n\t    // Get unique ID for picking interaction\n\t  }, {\n\t    key: '_setPickingId',\n\t    value: function _setPickingId() {\n\t      this._pickingId = this.getPickingId();\n\t    }\n\t\n\t    // Set up and re-emit interaction events\n\t  }, {\n\t    key: '_addPickingEvents',\n\t    value: function _addPickingEvents() {\n\t      var _this2 = this;\n\t\n\t      // TODO: Find a way to properly remove this listener on destroy\n\t      this._world.on('pick-' + this._pickingId, function (point2d, point3d, intersects) {\n\t        // Re-emit click event from the layer\n\t        _this2.emit('click', _this2, point2d, point3d, intersects);\n\t      });\n\t    }\n\t\n\t    // Create and store reference to THREE.BufferAttribute data for this layer\n\t  }, {\n\t    key: 'getBufferAttributes',\n\t    value: function getBufferAttributes() {\n\t      return this._bufferAttributes;\n\t    }\n\t  }, {\n\t    key: 'getOutlineBufferAttributes',\n\t    value: function getOutlineBufferAttributes() {\n\t      return this._outlineBufferAttributes;\n\t    }\n\t\n\t    // Used by external components to clear some memory when the attributes\n\t    // are no longer required to be stored in this layer\n\t    //\n\t    // For example, you would want to clear the attributes here after merging them\n\t    // using something like the GeoJSONLayer\n\t  }, {\n\t    key: 'clearBufferAttributes',\n\t    value: function clearBufferAttributes() {\n\t      this._bufferAttributes = null;\n\t      this._outlineBufferAttributes = null;\n\t    }\n\t\n\t    // Threshold angle is currently in rads\n\t  }, {\n\t    key: 'clearCoordinates',\n\t\n\t    // Used by external components to clear some memory when the coordinates\n\t    // are no longer required to be stored in this layer\n\t    //\n\t    // For example, you would want to clear the coordinates here after this\n\t    // layer is merged in something like the GeoJSONLayer\n\t    value: function clearCoordinates() {\n\t      this._coordinates = null;\n\t      this._projectedCoordinates = null;\n\t    }\n\t  }, {\n\t    key: '_setCoordinates',\n\t\n\t    // Convert and project coordinates\n\t    //\n\t    // TODO: Calculate bounds\n\t    value: function _setCoordinates() {\n\t      this._bounds = [];\n\t      this._coordinates = this._convertCoordinates(this._coordinates);\n\t\n\t      this._projectedBounds = [];\n\t      this._projectedCoordinates = this._projectCoordinates();\n\t\n\t      this._center = this._coordinates[0][0][0];\n\t    }\n\t\n\t    // Recursively convert input coordinates into LatLon objects\n\t    //\n\t    // Calculate geographic bounds at the same time\n\t    //\n\t    // TODO: Calculate geographic bounds\n\t  }, {\n\t    key: '_convertCoordinates',\n\t    value: function _convertCoordinates(coordinates) {\n\t      return coordinates.map(function (_coordinates) {\n\t        return _coordinates.map(function (ring) {\n\t          return ring.map(function (coordinate) {\n\t            return (0, _geoLatLon.latLon)(coordinate[1], coordinate[0]);\n\t          });\n\t        });\n\t      });\n\t    }\n\t\n\t    // Recursively project coordinates into world positions\n\t    //\n\t    // Calculate world bounds, offset and pointScale at the same time\n\t    //\n\t    // TODO: Calculate world bounds\n\t  }, {\n\t    key: '_projectCoordinates',\n\t    value: function _projectCoordinates() {\n\t      var _this3 = this;\n\t\n\t      var point;\n\t      return this._coordinates.map(function (_coordinates) {\n\t        return _coordinates.map(function (ring) {\n\t          return ring.map(function (latlon) {\n\t            point = _this3._world.latLonToPoint(latlon);\n\t\n\t            // TODO: Is offset ever being used or needed?\n\t            if (!_this3._offset) {\n\t              _this3._offset = (0, _geoPoint.point)(0, 0);\n\t              _this3._offset.x = -1 * point.x;\n\t              _this3._offset.y = -1 * point.y;\n\t\n\t              _this3._options.pointScale = _this3._world.pointScale(latlon);\n\t            }\n\t\n\t            return point;\n\t          });\n\t        });\n\t      });\n\t    }\n\t\n\t    // Convert coordinates array to something earcut can understand\n\t  }, {\n\t    key: 'isFlat',\n\t\n\t    // Returns true if the polygon is flat (has no height)\n\t    value: function isFlat() {\n\t      return this._flat;\n\t    }\n\t\n\t    // Returns true if coordinates refer to a single geometry\n\t    //\n\t    // For example, not coordinates for a MultiPolygon GeoJSON feature\n\t  }, {\n\t    key: 'destroy',\n\t\n\t    // TODO: Make sure this is cleaning everything\n\t    value: function destroy() {\n\t      if (this._pickingMesh) {\n\t        // TODO: Properly dispose of picking mesh\n\t        this._pickingMesh = null;\n\t      }\n\t\n\t      this.clearCoordinates();\n\t      this.clearBufferAttributes();\n\t\n\t      // Run common destruction logic from parent\n\t      _get(Object.getPrototypeOf(PolygonLayer.prototype), 'destroy', this).call(this);\n\t    }\n\t  }], [{\n\t    key: 'SetBufferAttributes',\n\t    value: function SetBufferAttributes(coordinates, options) {\n\t      return new Promise(function (resolve) {\n\t        var height = 0;\n\t\n\t        // Convert height into world units\n\t        if (options.style.height && options.style.height !== 0) {\n\t          height = _geoGeo2['default'].metresToWorld(options.style.height, options.pointScale);\n\t        }\n\t\n\t        var colour = new _three2['default'].Color();\n\t        colour.set(options.style.color);\n\t\n\t        // Light and dark colours used for poor-mans AO gradient on object sides\n\t        var light = new _three2['default'].Color(0xffffff);\n\t        var shadow = new _three2['default'].Color(0x666666);\n\t\n\t        var flat = true;\n\t\n\t        var outlineAttributes = [];\n\t\n\t        // For each polygon\n\t        var attributes = coordinates.map(function (_coordinates) {\n\t          // Convert coordinates to earcut format\n\t          var _earcut = PolygonLayer.ToEarcut(_coordinates);\n\t\n\t          // Triangulate faces using earcut\n\t          var faces = PolygonLayer.Triangulate(_earcut.vertices, _earcut.holes, _earcut.dimensions);\n\t\n\t          var groupedVertices = [];\n\t          for (i = 0, il = _earcut.vertices.length; i < il; i += _earcut.dimensions) {\n\t            groupedVertices.push(_earcut.vertices.slice(i, i + _earcut.dimensions));\n\t          }\n\t\n\t          var extruded = (0, _utilExtrudePolygon2['default'])(groupedVertices, faces, {\n\t            bottom: 0,\n\t            top: height\n\t          });\n\t\n\t          var topColor = colour.clone().multiply(light);\n\t          var bottomColor = colour.clone().multiply(shadow);\n\t\n\t          var _vertices = extruded.positions;\n\t          var _faces = [];\n\t          var _colours = [];\n\t          var _tops = [];\n\t\n\t          var _colour;\n\t          extruded.top.forEach(function (face, fi) {\n\t            _colour = [];\n\t\n\t            _colour.push([colour.r, colour.g, colour.b]);\n\t            _colour.push([colour.r, colour.g, colour.b]);\n\t            _colour.push([colour.r, colour.g, colour.b]);\n\t\n\t            _tops.push([true, true, true]);\n\t\n\t            _faces.push(face);\n\t            _colours.push(_colour);\n\t          });\n\t\n\t          if (extruded.sides) {\n\t            flat = false;\n\t\n\t            // Set up colours for every vertex with poor-mans AO on the sides\n\t            extruded.sides.forEach(function (face, fi) {\n\t              _colour = [];\n\t\n\t              // First face is always bottom-bottom-top\n\t              if (fi % 2 === 0) {\n\t                _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\t                _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\t                _colour.push([topColor.r, topColor.g, topColor.b]);\n\t\n\t                _tops.push([false, false, true]);\n\t                // Reverse winding for the second face\n\t                // top-top-bottom\n\t              } else {\n\t                  _colour.push([topColor.r, topColor.g, topColor.b]);\n\t                  _colour.push([topColor.r, topColor.g, topColor.b]);\n\t                  _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\t\n\t                  _tops.push([true, true, false]);\n\t                }\n\t\n\t              _faces.push(face);\n\t              _colours.push(_colour);\n\t            });\n\t          }\n\t\n\t          // Skip bottom as there's no point rendering it\n\t          // allFaces.push(extruded.faces);\n\t\n\t          var polygon = {\n\t            vertices: _vertices,\n\t            faces: _faces,\n\t            colours: _colours,\n\t            tops: _tops,\n\t            facesCount: _faces.length\n\t          };\n\t\n\t          if (options.style.outline) {\n\t            var outlineColour = new _three2['default'].Color();\n\t            outlineColour.set(options.style.outlineColor || 0x000000);\n\t\n\t            outlineAttributes.push(PolygonLayer.Set2DOutline(_coordinates, outlineColour));\n\t          }\n\t\n\t          if (options.interactive && options.pickingId) {\n\t            // Inject picking ID\n\t            polygon.pickingId = options.pickingId;\n\t          }\n\t\n\t          // Convert polygon representation to proper attribute arrays\n\t          return PolygonLayer.ToAttributes(polygon);\n\t        });\n\t\n\t        resolve({\n\t          attributes: attributes,\n\t          outlineAttributes: outlineAttributes,\n\t          flat: flat\n\t        });\n\t      });\n\t    }\n\t  }, {\n\t    key: 'Set2DOutline',\n\t    value: function Set2DOutline(coordinates, colour) {\n\t      var _vertices = [];\n\t\n\t      coordinates.forEach(function (ring) {\n\t        var _ring = ring.map(function (coordinate) {\n\t          return [coordinate.x, 0, coordinate.y];\n\t        });\n\t\n\t        // Add in duplicate vertices for line segments to work\n\t        var verticeCount = _ring.length;\n\t        var first = true;\n\t        while (--verticeCount) {\n\t          if (first || verticeCount === 0) {\n\t            first = false;\n\t            continue;\n\t          }\n\t\n\t          _ring.splice(verticeCount + 1, 0, _ring[verticeCount]);\n\t        }\n\t\n\t        _vertices = _vertices.concat(_ring);\n\t      });\n\t\n\t      _colour = [colour.r, colour.g, colour.b];\n\t\n\t      var vertices = new Float32Array(_vertices.length * 3);\n\t      var colours = new Float32Array(_vertices.length * 3);\n\t\n\t      var lastIndex = 0;\n\t\n\t      for (var i = 0; i < _vertices.length; i++) {\n\t        var ax = _vertices[i][0];\n\t        var ay = _vertices[i][1];\n\t        var az = _vertices[i][2];\n\t\n\t        var c1 = _colour;\n\t\n\t        vertices[lastIndex * 3 + 0] = ax;\n\t        vertices[lastIndex * 3 + 1] = ay;\n\t        vertices[lastIndex * 3 + 2] = az;\n\t\n\t        colours[lastIndex * 3 + 0] = c1[0];\n\t        colours[lastIndex * 3 + 1] = c1[1];\n\t        colours[lastIndex * 3 + 2] = c1[2];\n\t\n\t        lastIndex++;\n\t      }\n\t\n\t      var attributes = {\n\t        positions: vertices,\n\t        colors: colours\n\t      };\n\t\n\t      return attributes;\n\t    }\n\t  }, {\n\t    key: 'SetMesh',\n\t    value: function SetMesh(attributes, attributeLengths, flat, style, options, skybox) {\n\t      var geometry = new _three2['default'].BufferGeometry();\n\t\n\t      for (var key in attributes) {\n\t        geometry.addAttribute(key.slice(0, -1), new _three2['default'].BufferAttribute(attributes[key], attributeLengths[key]));\n\t      }\n\t\n\t      geometry.computeBoundingBox();\n\t\n\t      var material;\n\t      if (options.polygonMaterial && options.polygonMaterial instanceof _three2['default'].Material) {\n\t        material = options.polygonMaterial;\n\t      } else if (!skybox) {\n\t        material = new _three2['default'].MeshPhongMaterial({\n\t          vertexColors: _three2['default'].VertexColors,\n\t          side: _three2['default'].BackSide,\n\t          transparent: style.transparent,\n\t          opacity: style.opacity,\n\t          blending: style.blending\n\t        });\n\t      } else {\n\t        material = new _three2['default'].MeshStandardMaterial({\n\t          vertexColors: _three2['default'].VertexColors,\n\t          side: _three2['default'].BackSide,\n\t          transparent: style.transparent,\n\t          opacity: style.opacity,\n\t          blending: style.blending\n\t        });\n\t        material.roughness = 1;\n\t        material.metalness = 0.1;\n\t        material.envMapIntensity = 3;\n\t        material.envMap = skybox.getRenderTarget();\n\t      }\n\t\n\t      var mesh;\n\t\n\t      // Pass mesh through callback, if defined\n\t      if (typeof options.onPolygonMesh === 'function') {\n\t        mesh = options.onPolygonMesh(geometry, material);\n\t      } else {\n\t        mesh = new _three2['default'].Mesh(geometry, material);\n\t\n\t        mesh.castShadow = true;\n\t        mesh.receiveShadow = true;\n\t      }\n\t\n\t      if (flat) {\n\t        material.depthWrite = false;\n\t\n\t        var renderOrder = style.renderOrder !== undefined ? style.renderOrder : 3;\n\t        mesh.renderOrder = renderOrder;\n\t      }\n\t\n\t      if (options.interactive) {\n\t        material = new _enginePickingMaterial2['default']();\n\t        material.side = _three2['default'].BackSide;\n\t\n\t        var pickingMesh = new _three2['default'].Mesh(geometry, material);\n\t      }\n\t\n\t      return Promise.resolve({\n\t        mesh: mesh,\n\t        pickingMesh: pickingMesh\n\t      });\n\t    }\n\t  }, {\n\t    key: 'ToEarcut',\n\t    value: function ToEarcut(coordinates) {\n\t      var dim = 2;\n\t      var result = { vertices: [], holes: [], dimensions: dim };\n\t      var holeIndex = 0;\n\t\n\t      for (var i = 0; i < coordinates.length; i++) {\n\t        for (var j = 0; j < coordinates[i].length; j++) {\n\t          // for (var d = 0; d < dim; d++) {\n\t          result.vertices.push(coordinates[i][j].x);\n\t          result.vertices.push(coordinates[i][j].y);\n\t          // }\n\t        }\n\t        if (i > 0) {\n\t          holeIndex += coordinates[i - 1].length;\n\t          result.holes.push(holeIndex);\n\t        }\n\t      }\n\t\n\t      return result;\n\t    }\n\t\n\t    // Triangulate earcut-based input using earcut\n\t  }, {\n\t    key: 'Triangulate',\n\t    value: function Triangulate(contour, holes, dim) {\n\t      // console.time('earcut');\n\t\n\t      var faces = (0, _earcut3['default'])(contour, holes, dim);\n\t      var result = [];\n\t\n\t      for (i = 0, il = faces.length; i < il; i += 3) {\n\t        result.push(faces.slice(i, i + 3));\n\t      }\n\t\n\t      // console.timeEnd('earcut');\n\t\n\t      return result;\n\t    }\n\t\n\t    // Transform polygon representation into attribute arrays that can be used by\n\t    // THREE.BufferGeometry\n\t    //\n\t    // TODO: Can this be simplified? It's messy and huge\n\t  }, {\n\t    key: 'ToAttributes',\n\t    value: function ToAttributes(polygon) {\n\t      // Three components per vertex per face (3 x 3 = 9)\n\t      var positions = new Float32Array(polygon.facesCount * 9);\n\t      var normals = new Float32Array(polygon.facesCount * 9);\n\t      var colours = new Float32Array(polygon.facesCount * 9);\n\t\n\t      // One component per vertex per face (1 x 3 = 3)\n\t      var tops = new Float32Array(polygon.facesCount * 3);\n\t\n\t      var pickingIds;\n\t      if (polygon.pickingId) {\n\t        // One component per vertex per face (1 x 3 = 3)\n\t        pickingIds = new Float32Array(polygon.facesCount * 3);\n\t      }\n\t\n\t      var pA = new _three2['default'].Vector3();\n\t      var pB = new _three2['default'].Vector3();\n\t      var pC = new _three2['default'].Vector3();\n\t\n\t      var cb = new _three2['default'].Vector3();\n\t      var ab = new _three2['default'].Vector3();\n\t\n\t      var index;\n\t\n\t      var _faces = polygon.faces;\n\t      var _vertices = polygon.vertices;\n\t      var _colour = polygon.colours;\n\t      var _tops = polygon.tops;\n\t\n\t      var _pickingId;\n\t      if (pickingIds) {\n\t        _pickingId = polygon.pickingId;\n\t      }\n\t\n\t      var lastIndex = 0;\n\t\n\t      for (var i = 0; i < _faces.length; i++) {\n\t        // Array of vertex indexes for the face\n\t        index = _faces[i][0];\n\t\n\t        var ax = _vertices[index][0];\n\t        var ay = _vertices[index][1];\n\t        var az = _vertices[index][2];\n\t\n\t        var c1 = _colour[i][0];\n\t        var t1 = _tops[i][0];\n\t\n\t        index = _faces[i][1];\n\t\n\t        var bx = _vertices[index][0];\n\t        var by = _vertices[index][1];\n\t        var bz = _vertices[index][2];\n\t\n\t        var c2 = _colour[i][1];\n\t        var t2 = _tops[i][1];\n\t\n\t        index = _faces[i][2];\n\t\n\t        var cx = _vertices[index][0];\n\t        var cy = _vertices[index][1];\n\t        var cz = _vertices[index][2];\n\t\n\t        var c3 = _colour[i][2];\n\t        var t3 = _tops[i][2];\n\t\n\t        // Flat face normals\n\t        // From: http://threejs.org/examples/webgl_buffergeometry.html\n\t        pA.set(ax, ay, az);\n\t        pB.set(bx, by, bz);\n\t        pC.set(cx, cy, cz);\n\t\n\t        cb.subVectors(pC, pB);\n\t        ab.subVectors(pA, pB);\n\t        cb.cross(ab);\n\t\n\t        cb.normalize();\n\t\n\t        var nx = cb.x;\n\t        var ny = cb.y;\n\t        var nz = cb.z;\n\t\n\t        positions[lastIndex * 9 + 0] = ax;\n\t        positions[lastIndex * 9 + 1] = ay;\n\t        positions[lastIndex * 9 + 2] = az;\n\t\n\t        normals[lastIndex * 9 + 0] = nx;\n\t        normals[lastIndex * 9 + 1] = ny;\n\t        normals[lastIndex * 9 + 2] = nz;\n\t\n\t        colours[lastIndex * 9 + 0] = c1[0];\n\t        colours[lastIndex * 9 + 1] = c1[1];\n\t        colours[lastIndex * 9 + 2] = c1[2];\n\t\n\t        positions[lastIndex * 9 + 3] = bx;\n\t        positions[lastIndex * 9 + 4] = by;\n\t        positions[lastIndex * 9 + 5] = bz;\n\t\n\t        normals[lastIndex * 9 + 3] = nx;\n\t        normals[lastIndex * 9 + 4] = ny;\n\t        normals[lastIndex * 9 + 5] = nz;\n\t\n\t        colours[lastIndex * 9 + 3] = c2[0];\n\t        colours[lastIndex * 9 + 4] = c2[1];\n\t        colours[lastIndex * 9 + 5] = c2[2];\n\t\n\t        positions[lastIndex * 9 + 6] = cx;\n\t        positions[lastIndex * 9 + 7] = cy;\n\t        positions[lastIndex * 9 + 8] = cz;\n\t\n\t        normals[lastIndex * 9 + 6] = nx;\n\t        normals[lastIndex * 9 + 7] = ny;\n\t        normals[lastIndex * 9 + 8] = nz;\n\t\n\t        colours[lastIndex * 9 + 6] = c3[0];\n\t        colours[lastIndex * 9 + 7] = c3[1];\n\t        colours[lastIndex * 9 + 8] = c3[2];\n\t\n\t        tops[lastIndex * 3 + 0] = t1;\n\t        tops[lastIndex * 3 + 1] = t2;\n\t        tops[lastIndex * 3 + 2] = t3;\n\t\n\t        if (pickingIds) {\n\t          pickingIds[lastIndex * 3 + 0] = _pickingId;\n\t          pickingIds[lastIndex * 3 + 1] = _pickingId;\n\t          pickingIds[lastIndex * 3 + 2] = _pickingId;\n\t        }\n\t\n\t        lastIndex++;\n\t      }\n\t\n\t      var attributes = {\n\t        positions: positions,\n\t        normals: normals,\n\t        colors: colours,\n\t        tops: tops\n\t      };\n\t\n\t      if (pickingIds) {\n\t        attributes.pickingIds = pickingIds;\n\t      }\n\t\n\t      return attributes;\n\t    }\n\t  }, {\n\t    key: 'isSingle',\n\t    value: function isSingle(coordinates) {\n\t      return !Array.isArray(coordinates[0][0][0]);\n\t    }\n\t  }]);\n\t\n\t  return PolygonLayer;\n\t})(_Layer3['default']);\n\t\n\texports['default'] = PolygonLayer;\n\t\n\tvar noNew = function noNew(coordinates, options) {\n\t  return new PolygonLayer(coordinates, options);\n\t};\n\t\n\texports.polygonLayer = noNew;\n\n/***/ },\n/* 37 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _PickingShader = __webpack_require__(38);\n\t\n\tvar _PickingShader2 = _interopRequireDefault(_PickingShader);\n\t\n\t// FROM: https://github.com/brianxu/GPUPicker/blob/master/GPUPicker.js\n\t\n\tvar PickingMaterial = function PickingMaterial() {\n\t  _three2['default'].ShaderMaterial.call(this, {\n\t    uniforms: {\n\t      size: {\n\t        type: 'f',\n\t        value: 0.01\n\t      },\n\t      scale: {\n\t        type: 'f',\n\t        value: 400\n\t      }\n\t    },\n\t    // attributes: ['position', 'id'],\n\t    vertexShader: _PickingShader2['default'].vertexShader,\n\t    fragmentShader: _PickingShader2['default'].fragmentShader\n\t  });\n\t\n\t  this.linePadding = 2;\n\t};\n\t\n\tPickingMaterial.prototype = Object.create(_three2['default'].ShaderMaterial.prototype);\n\t\n\tPickingMaterial.prototype.constructor = PickingMaterial;\n\t\n\tPickingMaterial.prototype.setPointSize = function (size) {\n\t  this.uniforms.size.value = size;\n\t};\n\t\n\tPickingMaterial.prototype.setPointScale = function (scale) {\n\t  this.uniforms.scale.value = scale;\n\t};\n\t\n\texports['default'] = PickingMaterial;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 38 */\n/***/ function(module, exports) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t\tvalue: true\n\t});\n\t// FROM: https://github.com/brianxu/GPUPicker/blob/master/GPUPicker.js\n\t\n\tvar PickingShader = {\n\t\tvertexShader: ['attribute float pickingId;',\n\t\t// '',\n\t\t// 'uniform float size;',\n\t\t// 'uniform float scale;',\n\t\t'', 'varying vec4 worldId;', '', 'void main() {', '  vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',\n\t\t// '  gl_PointSize = size * ( scale / length( mvPosition.xyz ) );',\n\t\t'  vec3 a = fract(vec3(1.0/255.0, 1.0/(255.0*255.0), 1.0/(255.0*255.0*255.0)) * pickingId);', '  a -= a.xxy * vec3(0.0, 1.0/255.0, 1.0/255.0);', '  worldId = vec4(a,1);', '  gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\\n'),\n\t\n\t\tfragmentShader: ['#ifdef GL_ES\\n', 'precision highp float;\\n', '#endif\\n', '', 'varying vec4 worldId;', '', 'void main() {', '  gl_FragColor = worldId;', '}'].join('\\n')\n\t};\n\t\n\texports['default'] = PickingShader;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 39 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tvar _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\t// TODO: Move duplicated logic between geometry layrs into GeometryLayer\n\t\n\t// TODO: Look at ways to drop unneeded references to array buffers, etc to\n\t// reduce memory footprint\n\t\n\t// TODO: Provide alternative output using tubes and splines / curves\n\t\n\t// TODO: Support dynamic updating / hiding / animation of geometry\n\t//\n\t// This could be pretty hard as it's all packed away within BufferGeometry and\n\t// may even be merged by another layer (eg. GeoJSONLayer)\n\t//\n\t// How much control should this layer support? Perhaps a different or custom\n\t// layer would be better suited for animation, for example.\n\t\n\t// TODO: Allow _setBufferAttributes to use a custom function passed in to\n\t// generate a custom mesh\n\t\n\tvar _Layer2 = __webpack_require__(4);\n\t\n\tvar _Layer3 = _interopRequireDefault(_Layer2);\n\t\n\tvar _lodashAssign = __webpack_require__(6);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _geoGeo = __webpack_require__(1);\n\t\n\tvar _geoGeo2 = _interopRequireDefault(_geoGeo);\n\t\n\tvar _geoLatLon = __webpack_require__(2);\n\t\n\tvar _geoPoint = __webpack_require__(3);\n\t\n\tvar _enginePickingMaterial = __webpack_require__(37);\n\t\n\tvar _enginePickingMaterial2 = _interopRequireDefault(_enginePickingMaterial);\n\t\n\tvar _utilBuffer = __webpack_require__(34);\n\t\n\tvar _utilBuffer2 = _interopRequireDefault(_utilBuffer);\n\t\n\tvar PolylineLayer = (function (_Layer) {\n\t  _inherits(PolylineLayer, _Layer);\n\t\n\t  function PolylineLayer(coordinates, options) {\n\t    _classCallCheck(this, PolylineLayer);\n\t\n\t    var defaults = {\n\t      output: true,\n\t      interactive: false,\n\t      // Custom material override\n\t      //\n\t      // TODO: Should this be in the style object?\n\t      polylineMaterial: null,\n\t      onPolylineMesh: null,\n\t      onBufferAttributes: null,\n\t      // This default style is separate to Util.GeoJSON.defaultStyle\n\t      style: {\n\t        lineOpacity: 1,\n\t        lineTransparent: false,\n\t        lineColor: '#ffffff',\n\t        lineWidth: 1,\n\t        lineBlending: _three2['default'].NormalBlending\n\t      }\n\t    };\n\t\n\t    var _options = (0, _lodashAssign2['default'])({}, defaults, options);\n\t\n\t    _get(Object.getPrototypeOf(PolylineLayer.prototype), 'constructor', this).call(this, _options);\n\t\n\t    // Return coordinates as array of lines so it's easy to support\n\t    // MultiLineString features (a single line would be a MultiLineString with a\n\t    // single line in the array)\n\t    this._coordinates = PolylineLayer.isSingle(coordinates) ? [coordinates] : coordinates;\n\t\n\t    // Polyline features are always flat (for now at least)\n\t    this._flat = true;\n\t  }\n\t\n\t  _createClass(PolylineLayer, [{\n\t    key: '_onAdd',\n\t    value: function _onAdd(world) {\n\t      var _this = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        _this._setCoordinates();\n\t\n\t        if (_this._options.interactive) {\n\t          // Only add to picking mesh if this layer is controlling output\n\t          //\n\t          // Otherwise, assume another component will eventually add a mesh to\n\t          // the picking scene\n\t          if (_this.isOutput()) {\n\t            _this._pickingMesh = new _three2['default'].Object3D();\n\t            _this.addToPicking(_this._pickingMesh);\n\t          }\n\t\n\t          _this._setPickingId();\n\t          _this._addPickingEvents();\n\t        }\n\t\n\t        // Store geometry representation as instances of THREE.BufferAttribute\n\t        PolylineLayer.SetBufferAttributes(_this._projectedCoordinates, _this._options).then(function (result) {\n\t          _this._bufferAttributes = _utilBuffer2['default'].mergeAttributes(result.attributes);\n\t          _this._flat = result.flat;\n\t\n\t          var attributeLengths = {\n\t            positions: 3,\n\t            colors: 3\n\t          };\n\t\n\t          if (_this._options.interactive) {\n\t            attributeLengths.pickingIds = 1;\n\t          }\n\t\n\t          if (_this.isOutput()) {\n\t            var style = _this._options.style;\n\t\n\t            // Set mesh if not merging elsewhere\n\t            PolylineLayer.SetMesh(_this._bufferAttributes, attributeLengths, _this._flat, style, _this._options).then(function (result) {\n\t              // Output mesh\n\t              _this.add(result.mesh);\n\t\n\t              if (result.pickingMesh) {\n\t                _this._pickingMesh.add(result.pickingMesh);\n\t              }\n\t            });\n\t          }\n\t\n\t          result.attributes = null;\n\t          result = null;\n\t\n\t          resolve(_this);\n\t        });\n\t      });\n\t    }\n\t\n\t    // Return center of polyline as a LatLon\n\t    //\n\t    // This is used for things like placing popups / UI elements on the layer\n\t    //\n\t    // TODO: Find proper center position instead of returning first coordinate\n\t    // SEE: https://github.com/Leaflet/Leaflet/blob/master/src/layer/vector/Polyline.js#L59\n\t  }, {\n\t    key: 'getCenter',\n\t    value: function getCenter() {\n\t      return this._center;\n\t    }\n\t\n\t    // Return line bounds in geographic coordinates\n\t    //\n\t    // TODO: Implement getBounds()\n\t  }, {\n\t    key: 'getBounds',\n\t    value: function getBounds() {}\n\t\n\t    // Get unique ID for picking interaction\n\t  }, {\n\t    key: '_setPickingId',\n\t    value: function _setPickingId() {\n\t      this._pickingId = this.getPickingId();\n\t    }\n\t\n\t    // Set up and re-emit interaction events\n\t  }, {\n\t    key: '_addPickingEvents',\n\t    value: function _addPickingEvents() {\n\t      var _this2 = this;\n\t\n\t      // TODO: Find a way to properly remove this listener on destroy\n\t      this._world.on('pick-' + this._pickingId, function (point2d, point3d, intersects) {\n\t        // Re-emit click event from the layer\n\t        _this2.emit('click', _this2, point2d, point3d, intersects);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'getBufferAttributes',\n\t    value: function getBufferAttributes() {\n\t      return this._bufferAttributes;\n\t    }\n\t\n\t    // Used by external components to clear some memory when the attributes\n\t    // are no longer required to be stored in this layer\n\t    //\n\t    // For example, you would want to clear the attributes here after merging them\n\t    // using something like the GeoJSONLayer\n\t  }, {\n\t    key: 'clearBufferAttributes',\n\t    value: function clearBufferAttributes() {\n\t      this._bufferAttributes = null;\n\t    }\n\t\n\t    // Used by external components to clear some memory when the coordinates\n\t    // are no longer required to be stored in this layer\n\t    //\n\t    // For example, you would want to clear the coordinates here after this\n\t    // layer is merged in something like the GeoJSONLayer\n\t  }, {\n\t    key: 'clearCoordinates',\n\t    value: function clearCoordinates() {\n\t      this._coordinates = null;\n\t      this._projectedCoordinates = null;\n\t    }\n\t  }, {\n\t    key: '_setCoordinates',\n\t\n\t    // Convert and project coordinates\n\t    //\n\t    // TODO: Calculate bounds\n\t    value: function _setCoordinates() {\n\t      this._bounds = [];\n\t      this._coordinates = this._convertCoordinates(this._coordinates);\n\t\n\t      this._projectedBounds = [];\n\t      this._projectedCoordinates = this._projectCoordinates();\n\t\n\t      this._center = this._coordinates[0][0];\n\t    }\n\t\n\t    // Recursively convert input coordinates into LatLon objects\n\t    //\n\t    // Calculate geographic bounds at the same time\n\t    //\n\t    // TODO: Calculate geographic bounds\n\t  }, {\n\t    key: '_convertCoordinates',\n\t    value: function _convertCoordinates(coordinates) {\n\t      return coordinates.map(function (_coordinates) {\n\t        return _coordinates.map(function (coordinate) {\n\t          return (0, _geoLatLon.latLon)(coordinate[1], coordinate[0]);\n\t        });\n\t      });\n\t    }\n\t\n\t    // Recursively project coordinates into world positions\n\t    //\n\t    // Calculate world bounds, offset and pointScale at the same time\n\t    //\n\t    // TODO: Calculate world bounds\n\t  }, {\n\t    key: '_projectCoordinates',\n\t    value: function _projectCoordinates() {\n\t      var _this3 = this;\n\t\n\t      var point;\n\t      return this._coordinates.map(function (_coordinates) {\n\t        return _coordinates.map(function (latlon) {\n\t          point = _this3._world.latLonToPoint(latlon);\n\t\n\t          // TODO: Is offset ever being used or needed?\n\t          if (!_this3._offset) {\n\t            _this3._offset = (0, _geoPoint.point)(0, 0);\n\t            _this3._offset.x = -1 * point.x;\n\t            _this3._offset.y = -1 * point.y;\n\t\n\t            _this3._options.pointScale = _this3._world.pointScale(latlon);\n\t          }\n\t\n\t          return point;\n\t        });\n\t      });\n\t    }\n\t  }, {\n\t    key: 'isFlat',\n\t\n\t    // Returns true if the line is flat (has no height)\n\t    value: function isFlat() {\n\t      return this._flat;\n\t    }\n\t\n\t    // Returns true if coordinates refer to a single geometry\n\t    //\n\t    // For example, not coordinates for a MultiLineString GeoJSON feature\n\t  }, {\n\t    key: 'destroy',\n\t    value: function destroy() {\n\t      if (this._pickingMesh) {\n\t        // TODO: Properly dispose of picking mesh\n\t        this._pickingMesh = null;\n\t      }\n\t\n\t      this.clearCoordinates();\n\t      this.clearBufferAttributes();\n\t\n\t      // Run common destruction logic from parent\n\t      _get(Object.getPrototypeOf(PolylineLayer.prototype), 'destroy', this).call(this);\n\t    }\n\t  }], [{\n\t    key: 'SetBufferAttributes',\n\t    value: function SetBufferAttributes(coordinates, options) {\n\t      return new Promise(function (resolve) {\n\t        var height = 0;\n\t\n\t        // Convert height into world units\n\t        if (options.style.lineHeight) {\n\t          height = _geoGeo2['default'].metresToWorld(options.style.lineHeight, options.pointScale);\n\t        }\n\t\n\t        var colour = new _three2['default'].Color();\n\t        colour.set(options.style.lineColor);\n\t\n\t        var flat = true;\n\t\n\t        // For each line\n\t        var attributes = coordinates.map(function (_projectedCoordinates) {\n\t          var _vertices = [];\n\t          var _colours = [];\n\t\n\t          // Connect coordinate with the next to make a pair\n\t          //\n\t          // LineSegments requires pairs of vertices so repeat the last point if\n\t          // there's an odd number of vertices\n\t          var nextCoord;\n\t          _projectedCoordinates.forEach(function (coordinate, index) {\n\t            _colours.push([colour.r, colour.g, colour.b]);\n\t            _vertices.push([coordinate.x, height, coordinate.y]);\n\t\n\t            nextCoord = _projectedCoordinates[index + 1] ? _projectedCoordinates[index + 1] : coordinate;\n\t\n\t            _colours.push([colour.r, colour.g, colour.b]);\n\t            _vertices.push([nextCoord.x, height, nextCoord.y]);\n\t          });\n\t\n\t          var line = {\n\t            vertices: _vertices,\n\t            colours: _colours,\n\t            verticesCount: _vertices.length\n\t          };\n\t\n\t          if (options.interactive && options.pickingId) {\n\t            // Inject picking ID\n\t            line.pickingId = options.pickingId;\n\t          }\n\t\n\t          // Convert line representation to proper attribute arrays\n\t          return PolylineLayer.ToAttributes(line);\n\t        });\n\t\n\t        resolve({\n\t          attributes: attributes,\n\t          flat: flat\n\t        });\n\t      });\n\t    }\n\t  }, {\n\t    key: 'SetMesh',\n\t    value: function SetMesh(attributes, attributeLengths, flat, style, options) {\n\t      var geometry = new _three2['default'].BufferGeometry();\n\t\n\t      for (var key in attributes) {\n\t        geometry.addAttribute(key.slice(0, -1), new _three2['default'].BufferAttribute(attributes[key], attributeLengths[key]));\n\t      }\n\t\n\t      geometry.computeBoundingBox();\n\t\n\t      var material;\n\t      if (options.polylineMaterial && options.polylineMaterial instanceof _three2['default'].Material) {\n\t        material = options.polylineMaterial;\n\t      } else {\n\t        material = new _three2['default'].LineBasicMaterial({\n\t          vertexColors: _three2['default'].VertexColors,\n\t          linewidth: style.lineWidth,\n\t          transparent: style.lineTransparent,\n\t          opacity: style.lineOpacity,\n\t          blending: style.lineBlending\n\t        });\n\t      }\n\t\n\t      var mesh;\n\t\n\t      // Pass mesh through callback, if defined\n\t      if (typeof options.onPolylineMesh === 'function') {\n\t        mesh = options.onPolylineMesh(geometry, material);\n\t      } else {\n\t        mesh = new _three2['default'].LineSegments(geometry, material);\n\t\n\t        if (style.lineRenderOrder !== undefined) {\n\t          material.depthWrite = false;\n\t          mesh.renderOrder = style.lineRenderOrder;\n\t        }\n\t\n\t        mesh.castShadow = true;\n\t        // mesh.receiveShadow = true;\n\t      }\n\t\n\t      if (options.interactive) {\n\t        material = new _enginePickingMaterial2['default']();\n\t        // material.side = THREE.BackSide;\n\t\n\t        // Make the line wider / easier to pick\n\t        material.linewidth = style.lineWidth + material.linePadding;\n\t\n\t        var pickingMesh = new _three2['default'].LineSegments(geometry, material);\n\t      }\n\t\n\t      return Promise.resolve({\n\t        mesh: mesh,\n\t        pickingMesh: pickingMesh\n\t      });\n\t    }\n\t  }, {\n\t    key: 'ToAttributes',\n\t    value: function ToAttributes(line) {\n\t      // Three components per vertex\n\t      var vertices = new Float32Array(line.verticesCount * 3);\n\t      var colours = new Float32Array(line.verticesCount * 3);\n\t\n\t      var pickingIds;\n\t      if (line.pickingId) {\n\t        // One component per vertex\n\t        pickingIds = new Float32Array(line.verticesCount);\n\t      }\n\t\n\t      var _vertices = line.vertices;\n\t      var _colour = line.colours;\n\t\n\t      var _pickingId;\n\t      if (pickingIds) {\n\t        _pickingId = line.pickingId;\n\t      }\n\t\n\t      var lastIndex = 0;\n\t\n\t      for (var i = 0; i < _vertices.length; i++) {\n\t        var ax = _vertices[i][0];\n\t        var ay = _vertices[i][1];\n\t        var az = _vertices[i][2];\n\t\n\t        var c1 = _colour[i];\n\t\n\t        vertices[lastIndex * 3 + 0] = ax;\n\t        vertices[lastIndex * 3 + 1] = ay;\n\t        vertices[lastIndex * 3 + 2] = az;\n\t\n\t        colours[lastIndex * 3 + 0] = c1[0];\n\t        colours[lastIndex * 3 + 1] = c1[1];\n\t        colours[lastIndex * 3 + 2] = c1[2];\n\t\n\t        if (pickingIds) {\n\t          pickingIds[lastIndex] = _pickingId;\n\t        }\n\t\n\t        lastIndex++;\n\t      }\n\t\n\t      var attributes = {\n\t        positions: vertices,\n\t        colors: colours\n\t      };\n\t\n\t      if (pickingIds) {\n\t        attributes.pickingIds = pickingIds;\n\t      }\n\t\n\t      return attributes;\n\t    }\n\t  }, {\n\t    key: 'isSingle',\n\t    value: function isSingle(coordinates) {\n\t      return !Array.isArray(coordinates[0][0]);\n\t    }\n\t  }]);\n\t\n\t  return PolylineLayer;\n\t})(_Layer3['default']);\n\t\n\texports['default'] = PolylineLayer;\n\t\n\tvar noNew = function noNew(coordinates, options) {\n\t  return new PolylineLayer(coordinates, options);\n\t};\n\t\n\texports.polylineLayer = noNew;\n\n/***/ },\n/* 40 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tvar _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\t\n\t// TODO: Move duplicated logic between geometry layrs into GeometryLayer\n\t\n\t// TODO: Look at ways to drop unneeded references to array buffers, etc to\n\t// reduce memory footprint\n\t\n\t// TODO: Point features may be using custom models / meshes and so an approach\n\t// needs to be found to allow these to be brokwn down into buffer attributes for\n\t// merging\n\t//\n\t// Can probably use fromGeometry() or setFromObject() from THREE.BufferGeometry\n\t// and pull out the attributes\n\t\n\t// TODO: Support sprite objects using textures\n\t\n\t// TODO: Provide option to billboard geometry so it always faces the camera\n\t\n\t// TODO: Support dynamic updating / hiding / animation of geometry\n\t//\n\t// This could be pretty hard as it's all packed away within BufferGeometry and\n\t// may even be merged by another layer (eg. GeoJSONLayer)\n\t//\n\t// How much control should this layer support? Perhaps a different or custom\n\t// layer would be better suited for animation, for example.\n\t\n\tvar _Layer2 = __webpack_require__(4);\n\t\n\tvar _Layer3 = _interopRequireDefault(_Layer2);\n\t\n\tvar _lodashAssign = __webpack_require__(6);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _three = __webpack_require__(18);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _geoGeo = __webpack_require__(1);\n\t\n\tvar _geoGeo2 = _interopRequireDefault(_geoGeo);\n\t\n\tvar _geoLatLon = __webpack_require__(2);\n\t\n\tvar _geoPoint = __webpack_require__(3);\n\t\n\tvar _enginePickingMaterial = __webpack_require__(37);\n\t\n\tvar _enginePickingMaterial2 = _interopRequireDefault(_enginePickingMaterial);\n\t\n\tvar _utilBuffer = __webpack_require__(34);\n\t\n\tvar _utilBuffer2 = _interopRequireDefault(_utilBuffer);\n\t\n\tvar _PolygonLayer = __webpack_require__(36);\n\t\n\tvar _PolygonLayer2 = _interopRequireDefault(_PolygonLayer);\n\t\n\tvar PointLayer = (function (_Layer) {\n\t  _inherits(PointLayer, _Layer);\n\t\n\t  function PointLayer(coordinates, options) {\n\t    _classCallCheck(this, PointLayer);\n\t\n\t    var defaults = {\n\t      output: true,\n\t      interactive: false,\n\t      // THREE.Geometry or THREE.BufferGeometry to use for point output\n\t      pointGeometry: null,\n\t      // Custom material override\n\t      //\n\t      // TODO: Should this be in the style object?\n\t      pointMaterial: null,\n\t      onPointMesh: null,\n\t      // This default style is separate to Util.GeoJSON.defaultStyle\n\t      style: {\n\t        pointColor: '#ff0000'\n\t      }\n\t    };\n\t\n\t    var _options = (0, _lodashAssign2['default'])({}, defaults, options);\n\t\n\t    _get(Object.getPrototypeOf(PointLayer.prototype), 'constructor', this).call(this, _options);\n\t\n\t    // Return coordinates as array of points so it's easy to support\n\t    // MultiPoint features (a single point would be a MultiPoint with a\n\t    // single point in the array)\n\t    this._coordinates = PointLayer.isSingle(coordinates) ? [coordinates] : coordinates;\n\t\n\t    this._flat = false;\n\t  }\n\t\n\t  _createClass(PointLayer, [{\n\t    key: '_onAdd',\n\t    value: function _onAdd(world) {\n\t      var _this = this;\n\t\n\t      return new Promise(function (resolve, reject) {\n\t        _this._setCoordinates();\n\t\n\t        if (_this._options.interactive) {\n\t          // Only add to picking mesh if this layer is controlling output\n\t          //\n\t          // Otherwise, assume another component will eventually add a mesh to\n\t          // the picking scene\n\t          if (_this.isOutput()) {\n\t            _this._pickingMesh = new _three2['default'].Object3D();\n\t            _this.addToPicking(_this._pickingMesh);\n\t          }\n\t\n\t          _this._setPickingId();\n\t          _this._addPickingEvents();\n\t        }\n\t\n\t        // Store geometry representation as instances of THREE.BufferAttribute\n\t        PointLayer.SetBufferAttributes(_this._projectedCoordinates, _this._options).then(function (result) {\n\t          _this._bufferAttributes = _utilBuffer2['default'].mergeAttributes(result.attributes);\n\t          _this._flat = result.flat;\n\t\n\t          var attributeLengths = {\n\t            positions: 3,\n\t            normals: 3,\n\t            colors: 3\n\t          };\n\t\n\t          if (_this._options.interactive) {\n\t            attributeLengths.pickingIds = 1;\n\t          }\n\t\n\t          if (_this.isOutput()) {\n\t            var style = _this._options.style;\n\t\n\t            // Set mesh if not merging elsewhere\n\t            // TODO: Dedupe with PolygonLayer as they are identical\n\t            PointLayer.SetMesh(_this._bufferAttributes, attributeLengths, _this._flat, style, _this._options, _this._world._environment._skybox).then(function (result) {\n\t              // Output mesh\n\t              _this.add(result.mesh);\n\t\n\t              if (result.pickingMesh) {\n\t                _this._pickingMesh.add(result.pickingMesh);\n\t              }\n\t            });\n\t          }\n\t\n\t          result.attributes = null;\n\t          result = null;\n\t\n\t          resolve(_this);\n\t        })['catch'](reject);\n\t      });\n\t    }\n\t\n\t    // Return center of point as a LatLon\n\t    //\n\t    // This is used for things like placing popups / UI elements on the layer\n\t  }, {\n\t    key: 'getCenter',\n\t    value: function getCenter() {\n\t      return this._center;\n\t    }\n\t\n\t    // Return point bounds in geographic coordinates\n\t    //\n\t    // While not useful for single points, it could be useful for MultiPoint\n\t    //\n\t    // TODO: Implement getBounds()\n\t  }, {\n\t    key: 'getBounds',\n\t    value: function getBounds() {}\n\t\n\t    // Get unique ID for picking interaction\n\t  }, {\n\t    key: '_setPickingId',\n\t    value: function _setPickingId() {\n\t      this._pickingId = this.getPickingId();\n\t    }\n\t\n\t    // Set up and re-emit interaction events\n\t  }, {\n\t    key: '_addPickingEvents',\n\t    value: function _addPickingEvents() {\n\t      var _this2 = this;\n\t\n\t      // TODO: Find a way to properly remove this listener on destroy\n\t      this._world.on('pick-' + this._pickingId, function (point2d, point3d, intersects) {\n\t        // Re-emit click event from the layer\n\t        _this2.emit('click', _this2, point2d, point3d, intersects);\n\t      });\n\t    }\n\t  }, {\n\t    key: 'getBufferAttributes',\n\t    value: function getBufferAttributes() {\n\t      return this._bufferAttributes;\n\t    }\n\t\n\t    // Used by external components to clear some memory when the attributes\n\t    // are no longer required to be stored in this layer\n\t    //\n\t    // For example, you would want to clear the attributes here after merging them\n\t    // using something like the GeoJSONLayer\n\t  }, {\n\t    key: 'clearBufferAttributes',\n\t    value: function clearBufferAttributes() {\n\t      this._bufferAttributes = null;\n\t    }\n\t\n\t    // Used by external components to clear some memory when the coordinates\n\t    // are no longer required to be stored in this layer\n\t    //\n\t    // For example, you would want to clear the coordinates here after this\n\t    // layer is merged in something like the GeoJSONLayer\n\t  }, {\n\t    key: 'clearCoordinates',\n\t    value: function clearCoordinates() {\n\t      this._coordinates = null;\n\t      this._projectedCoordinates = null;\n\t    }\n\t  }, {\n\t    key: '_setCoordinates',\n\t\n\t    // Convert and project coordinates\n\t    //\n\t    // TODO: Calculate bounds\n\t    value: function _setCoordinates() {\n\t      this._bounds = [];\n\t      this._coordinates = this._convertCoordinates(this._coordinates);\n\t\n\t      this._projectedBounds = [];\n\t      this._projectedCoordinates = this._projectCoordinates();\n\t\n\t      this._center = this._coordinates;\n\t    }\n\t\n\t    // Recursively convert input coordinates into LatLon objects\n\t    //\n\t    // Calculate geographic bounds at the same time\n\t    //\n\t    // TODO: Calculate geographic bounds\n\t  }, {\n\t    key: '_convertCoordinates',\n\t    value: function _convertCoordinates(coordinates) {\n\t      return coordinates.map(function (coordinate) {\n\t        return (0, _geoLatLon.latLon)(coordinate[1], coordinate[0]);\n\t      });\n\t    }\n\t\n\t    // Recursively project coordinates into world positions\n\t    //\n\t    // Calculate world bounds, offset and pointScale at the same time\n\t    //\n\t    // TODO: Calculate world bounds\n\t  }, {\n\t    key: '_projectCoordinates',\n\t    value: function _projectCoordinates() {\n\t      var _this3 = this;\n\t\n\t      var _point;\n\t      return this._coordinates.map(function (latlon) {\n\t        _point = _this3._world.latLonToPoint(latlon);\n\t\n\t        // TODO: Is offset ever being used or needed?\n\t        if (!_this3._offset) {\n\t          _this3._offset = (0, _geoPoint.point)(0, 0);\n\t          _this3._offset.x = -1 * _point.x;\n\t          _this3._offset.y = -1 * _point.y;\n\t\n\t          _this3._options.pointScale = _this3._world.pointScale(latlon);\n\t        }\n\t\n\t        return _point;\n\t      });\n\t    }\n\t\n\t    // Returns true if the line is flat (has no height)\n\t  }, {\n\t    key: 'isFlat',\n\t    value: function isFlat() {\n\t      return this._flat;\n\t    }\n\t\n\t    // Returns true if coordinates refer to a single geometry\n\t    //\n\t    // For example, not coordinates for a MultiPoint GeoJSON feature\n\t  }, {\n\t    key: 'destroy',\n\t    value: function destroy() {\n\t      if (this._pickingMesh) {\n\t        // TODO: Properly dispose of picking mesh\n\t        this._pickingMesh = null;\n\t      }\n\t\n\t      this.clearCoordinates();\n\t      this.clearBufferAttributes();\n\t\n\t      // Run common destruction logic from parent\n\t      _get(Object.getPrototypeOf(PointLayer.prototype), 'destroy', this).call(this);\n\t    }\n\t  }], [{\n\t    key: 'SetBufferAttributes',\n\t    value: function SetBufferAttributes(coordinates, options) {\n\t      return new Promise(function (resolve) {\n\t        var height = 0;\n\t\n\t        // Convert height into world units\n\t        if (options.style.pointHeight) {\n\t          height = _geoGeo2['default'].metresToWorld(options.style.pointHeight, options.pointScale);\n\t        }\n\t\n\t        var colour = new _three2['default'].Color();\n\t        colour.set(options.style.pointColor);\n\t\n\t        // Use default geometry if none has been provided or the provided geometry\n\t        // isn't valid\n\t        if (!options.pointGeometry || !options.pointGeometry instanceof _three2['default'].Geometry || !options.pointGeometry instanceof _three2['default'].BufferGeometry) {\n\t          // Debug geometry for points is a thin bar\n\t          //\n\t          // TODO: Allow point geometry to be customised / overridden\n\t          var geometryWidth = _geoGeo2['default'].metresToWorld(25, options.pointScale);\n\t          var geometryHeight = _geoGeo2['default'].metresToWorld(200, options.pointScale);\n\t          var _geometry = new _three2['default'].BoxGeometry(geometryWidth, geometryHeight, geometryWidth);\n\t\n\t          // Shift geometry up so it sits on the ground\n\t          _geometry.translate(0, geometryHeight * 0.5, 0);\n\t\n\t          // Pull attributes out of debug geometry\n\t          geometry = new _three2['default'].BufferGeometry().fromGeometry(_geometry);\n\t        } else {\n\t          if (options.geometry instanceof _three2['default'].BufferGeometry) {\n\t            geometry = options.pointGeometry;\n\t          } else {\n\t            geometry = new _three2['default'].BufferGeometry().fromGeometry(options.pointGeometry);\n\t          }\n\t        }\n\t\n\t        var attributes = coordinates.map(function (coordinate) {\n\t          var _vertices = [];\n\t          var _normals = [];\n\t          var _colours = [];\n\t\n\t          var _geometry = geometry.clone();\n\t          _geometry.translate(coordinate.x, height, coordinate.y);\n\t\n\t          var _vertices = _geometry.attributes.position.clone().array;\n\t          var _normals = _geometry.attributes.normal.clone().array;\n\t          var _colours = _geometry.attributes.color.clone().array;\n\t\n\t          for (var i = 0; i < _colours.length; i += 3) {\n\t            _colours[i] = colour.r;\n\t            _colours[i + 1] = colour.g;\n\t            _colours[i + 2] = colour.b;\n\t          }\n\t\n\t          var _point = {\n\t            positions: _vertices,\n\t            normals: _normals,\n\t            colors: _colours\n\t          };\n\t\n\t          if (options.interactive && options.pickingId) {\n\t            // Inject picking ID\n\t            _point.pickingId = options.pickingId;\n\t          }\n\t\n\t          return _point;\n\t        });\n\t\n\t        resolve({\n\t          attributes: attributes,\n\t          flat: false\n\t        });\n\t      });\n\t    }\n\t  }, {\n\t    key: 'SetMesh',\n\t    value: function SetMesh(attributes, attributeLengths, flat, style, options, skybox) {\n\t      var geometry = new _three2['default'].BufferGeometry();\n\t\n\t      for (var key in attributes) {\n\t        geometry.addAttribute(key.slice(0, -1), new _three2['default'].BufferAttribute(attributes[key], attributeLengths[key]));\n\t      }\n\t\n\t      geometry.computeBoundingBox();\n\t\n\t      var material;\n\t      if (options.pointMaterial && options.pointMaterial instanceof _three2['default'].Material) {\n\t        material = options.pointMaterial;\n\t      } else if (!skybox) {\n\t        material = new _three2['default'].MeshPhongMaterial({\n\t          vertexColors: _three2['default'].VertexColors,\n\t          // side: THREE.BackSide,\n\t          transparent: style.transparent,\n\t          opacity: style.opacity,\n\t          blending: style.blending\n\t        });\n\t      } else {\n\t        material = new _three2['default'].MeshStandardMaterial({\n\t          vertexColors: _three2['default'].VertexColors,\n\t          // side: THREE.BackSide,\n\t          transparent: style.transparent,\n\t          opacity: style.opacity,\n\t          blending: style.blending\n\t        });\n\t        material.roughness = 1;\n\t        material.metalness = 0.1;\n\t        material.envMapIntensity = 3;\n\t        material.envMap = skybox.getRenderTarget();\n\t      }\n\t\n\t      var mesh;\n\t\n\t      // Pass mesh through callback, if defined\n\t      if (typeof options.onPolygonMesh === 'function') {\n\t        mesh = options.onPolygonMesh(geometry, material);\n\t      } else {\n\t        mesh = new _three2['default'].Mesh(geometry, material);\n\t\n\t        mesh.castShadow = true;\n\t        mesh.receiveShadow = true;\n\t      }\n\t\n\t      if (flat) {\n\t        material.depthWrite = false;\n\t        mesh.renderOrder = 4;\n\t      }\n\t\n\t      if (options.interactive) {\n\t        material = new _enginePickingMaterial2['default']();\n\t        material.side = _three2['default'].BackSide;\n\t\n\t        var pickingMesh = new _three2['default'].Mesh(geometry, material);\n\t      }\n\t\n\t      return Promise.resolve({\n\t        mesh: mesh,\n\t        pickingMesh: pickingMesh\n\t      });\n\t    }\n\t  }, {\n\t    key: 'isSingle',\n\t    value: function isSingle(coordinates) {\n\t      return !Array.isArray(coordinates[0]);\n\t    }\n\t  }]);\n\t\n\t  return PointLayer;\n\t})(_Layer3['default']);\n\t\n\texports['default'] = PointLayer;\n\t\n\tvar noNew = function noNew(coordinates, options) {\n\t  return new PointLayer(coordinates, options);\n\t};\n\t\n\texports.pointLayer = noNew;\n\n/***/ },\n/* 41 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t// TODO: A lot of these utils don't need to be in separate, tiny files\n\t\n\tvar _wrapNum = __webpack_require__(42);\n\t\n\tvar _wrapNum2 = _interopRequireDefault(_wrapNum);\n\t\n\tvar _extrudePolygon = __webpack_require__(30);\n\t\n\tvar _extrudePolygon2 = _interopRequireDefault(_extrudePolygon);\n\t\n\tvar _GeoJSON = __webpack_require__(25);\n\t\n\tvar _GeoJSON2 = _interopRequireDefault(_GeoJSON);\n\t\n\tvar _Buffer = __webpack_require__(34);\n\t\n\tvar _Buffer2 = _interopRequireDefault(_Buffer);\n\t\n\tvar _Worker = __webpack_require__(31);\n\t\n\tvar _Worker2 = _interopRequireDefault(_Worker);\n\t\n\tvar _Stringify = __webpack_require__(35);\n\t\n\tvar _Stringify2 = _interopRequireDefault(_Stringify);\n\t\n\tvar Util = {};\n\t\n\tUtil.wrapNum = _wrapNum2['default'];\n\tUtil.extrudePolygon = _extrudePolygon2['default'];\n\tUtil.GeoJSON = _GeoJSON2['default'];\n\tUtil.Buffer = _Buffer2['default'];\n\tUtil.Worker = _Worker2['default'];\n\tUtil.Stringify = _Stringify2['default'];\n\t\n\texports['default'] = Util;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 42 */\n/***/ function(module, exports) {\n\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t/*\n\t * Wrap the given number to lie within a certain range (eg. longitude)\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/core/Util.js\n\t */\n\t\n\tvar wrapNum = function wrapNum(x, range, includeMax) {\n\t  var max = range[1];\n\t  var min = range[0];\n\t  var d = max - min;\n\t  return x === max && includeMax ? x : ((x - min) % d + d) % d + min;\n\t};\n\t\n\texports[\"default\"] = wrapNum;\n\tmodule.exports = exports[\"default\"];\n\n/***/ }\n/******/ ])\n});\n;"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 8912944b678b5a293f37\n **/","import Geo from './geo/Geo.js';\nimport Layer, {layer} from './layer/Layer';\nimport GeoJSONWorkerLayer, {geoJSONWorkerLayer} from './layer/GeoJSONWorkerLayer';\nimport PolygonLayer, {polygonLayer} from './layer/geometry/PolygonLayer';\n\nimport Point, {point} from './geo/Point';\nimport LatLon, {latLon} from './geo/LatLon';\n\nimport Util from './util/index';\n\nconst VIZI = {\n  version: '0.3',\n\n  Geo: Geo,\n  Layer: Layer,\n  layer: layer,\n  GeoJSONWorkerLayer: GeoJSONWorkerLayer,\n  geoJSONWorkerLayer: geoJSONWorkerLayer,\n  PolygonLayer: PolygonLayer,\n  polygonLayer: polygonLayer,\n  Point: Point,\n  point: point,\n  LatLon: LatLon,\n  latLon: latLon,\n  Util: Util\n};\n\nexport default VIZI;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/vizicities-worker.js\n **/","import {latLon as LatLon} from './LatLon';\nimport {point as Point} from './Point';\n\nvar Geo = {};\n\n// Radius / WGS84 semi-major axis\nGeo.R = 6378137;\nGeo.MAX_LATITUDE = 85.0511287798;\n\n// WGS84 eccentricity\nGeo.ECC = 0.081819191;\nGeo.ECC2 = 0.081819191 * 0.081819191;\n\nGeo.project = function(latlon) {\n  var d = Math.PI / 180;\n  var max = Geo.MAX_LATITUDE;\n  var lat = Math.max(Math.min(max, latlon.lat), -max);\n  var sin = Math.sin(lat * d);\n\n  return Point(\n    Geo.R * latlon.lon * d,\n    Geo.R * Math.log((1 + sin) / (1 - sin)) / 2\n  );\n},\n\nGeo.unproject = function(point) {\n  var d = 180 / Math.PI;\n\n  return LatLon(\n    (2 * Math.atan(Math.exp(point.y / Geo.R)) - (Math.PI / 2)) * d,\n    point.x * d / Geo.R\n  );\n};\n\n// Converts geo coords to pixel / WebGL ones\n// This just reverses the Y axis to match WebGL\nGeo.latLonToPoint = function(latlon) {\n  var projected = Geo.project(latlon);\n  projected.y *= -1;\n\n  return projected;\n};\n\n// Converts pixel / WebGL coords to geo coords\n// This just reverses the Y axis to match WebGL\nGeo.pointToLatLon = function(point) {\n  var _point = Point(point.x, point.y * -1);\n  return Geo.unproject(_point);\n};\n\n// Scale factor for converting between real metres and projected metres\n//\n// projectedMetres = realMetres * pointScale\n// realMetres = projectedMetres / pointScale\n//\n// Accurate scale factor uses proper Web Mercator scaling\n// See pg.9: http://www.hydrometronics.com/downloads/Web%20Mercator%20-%20Non-Conformal,%20Non-Mercator%20(notes).pdf\n// See: http://jsfiddle.net/robhawkes/yws924cf/\nGeo.pointScale = function(latlon, accurate) {\n  var rad = Math.PI / 180;\n\n  var k;\n\n  if (!accurate) {\n    k = 1 / Math.cos(latlon.lat * rad);\n\n    // [scaleX, scaleY]\n    return [k, k];\n  } else {\n    var lat = latlon.lat * rad;\n    var lon = latlon.lon * rad;\n\n    var a = Geo.R;\n\n    var sinLat = Math.sin(lat);\n    var sinLat2 = sinLat * sinLat;\n\n    var cosLat = Math.cos(lat);\n\n    // Radius meridian\n    var p = a * (1 - Geo.ECC2) / Math.pow(1 - Geo.ECC2 * sinLat2, 3 / 2);\n\n    // Radius prime meridian\n    var v = a / Math.sqrt(1 - Geo.ECC2 * sinLat2);\n\n    // Scale N/S\n    var h = (a / p) / cosLat;\n\n    // Scale E/W\n    k = (a / v) / cosLat;\n\n    // [scaleX, scaleY]\n    return [k, h];\n  }\n};\n\n// Convert real metres to projected units\n//\n// Latitude scale is chosen because it fluctuates more than longitude\nGeo.metresToProjected = function(metres, pointScale) {\n  return metres * pointScale[1];\n};\n\n// Convert projected units to real metres\n//\n// Latitude scale is chosen because it fluctuates more than longitude\nGeo.projectedToMetres = function(projectedUnits, pointScale) {\n  return projectedUnits / pointScale[1];\n};\n\n// Convert real metres to a value in world (WebGL) units\nGeo.metresToWorld = function(metres, pointScale) {\n  // Transform metres to projected metres using the latitude point scale\n  //\n  // Latitude scale is chosen because it fluctuates more than longitude\n  var projectedMetres = Geo.metresToProjected(metres, pointScale);\n\n  var scale = Geo.scale();\n\n  // Scale projected metres\n  var scaledMetres = (scale * projectedMetres);\n\n  return scaledMetres;\n};\n\n// Convert world (WebGL) units to a value in real metres\nGeo.worldToMetres = function(worldUnits, pointScale) {\n  var scale = Geo.scale();\n\n  var projectedUnits = worldUnits / scale;\n  var realMetres = Geo.projectedToMetres(projectedUnits, pointScale);\n\n  return realMetres;\n};\n\n// If zoom is provided, returns the map width in pixels for a given zoom\n// Else, provides fixed scale value\nGeo.scale = function(zoom) {\n  // If zoom is provided then return scale based on map tile zoom\n  if (zoom >= 0) {\n    return 256 * Math.pow(2, zoom);\n  // Else, return fixed scale value to expand projected coordinates from\n  // their 0 to 1 range into something more practical\n  } else {\n    return 1;\n  }\n};\n\n// Returns zoom level for a given scale value\n// This only works with a scale value that is based on map pixel width\nGeo.zoom = function(scale) {\n  return Math.log(scale / 256) / Math.LN2;\n};\n\n// Distance between two geographical points using spherical law of cosines\n// approximation or Haversine\n//\n// See: http://www.movable-type.co.uk/scripts/latlong.html\nGeo.distance = function(latlon1, latlon2, accurate) {\n  var rad = Math.PI / 180;\n\n  var lat1;\n  var lat2;\n\n  var a;\n\n  if (!accurate) {\n    lat1 = latlon1.lat * rad;\n    lat2 = latlon2.lat * rad;\n\n    a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((latlon2.lon - latlon1.lon) * rad);\n\n    return Geo.R * Math.acos(Math.min(a, 1));\n  } else {\n    lat1 = latlon1.lat * rad;\n    lat2 = latlon2.lat * rad;\n\n    var lon1 = latlon1.lon * rad;\n    var lon2 = latlon2.lon * rad;\n\n    var deltaLat = lat2 - lat1;\n    var deltaLon = lon2 - lon1;\n\n    var halfDeltaLat = deltaLat / 2;\n    var halfDeltaLon = deltaLon / 2;\n\n    a = Math.sin(halfDeltaLat) * Math.sin(halfDeltaLat) + Math.cos(lat1) * Math.cos(lat2) * Math.sin(halfDeltaLon) * Math.sin(halfDeltaLon);\n\n    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n    return Geo.R * c;\n  }\n};\n\nGeo.bounds = (function() {\n  var d = Geo.R * Math.PI;\n  return [[-d, -d], [d, d]];\n})();\n\nexport default Geo;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/Geo.js\n **/","/*\n * LatLon is a helper class for ensuring consistent geographic coordinates.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/LatLng.js\n */\n\nclass LatLon {\n  constructor(lat, lon, alt) {\n    if (isNaN(lat) || isNaN(lon)) {\n      throw new Error('Invalid LatLon object: (' + lat + ', ' + lon + ')');\n    }\n\n    this.lat = +lat;\n    this.lon = +lon;\n\n    if (alt !== undefined) {\n      this.alt = +alt;\n    }\n  }\n\n  clone() {\n    return new LatLon(this.lat, this.lon, this.alt);\n  }\n}\n\nexport default LatLon;\n\n// Accepts (LatLon), ([lat, lon, alt]), ([lat, lon]) and (lat, lon, alt)\n// Also converts between lng and lon\nvar noNew = function(a, b, c) {\n  if (a instanceof LatLon) {\n    return a;\n  }\n  if (Array.isArray(a) && typeof a[0] !== 'object') {\n    if (a.length === 3) {\n      return new LatLon(a[0], a[1], a[2]);\n    }\n    if (a.length === 2) {\n      return new LatLon(a[0], a[1]);\n    }\n    return null;\n  }\n  if (a === undefined || a === null) {\n    return a;\n  }\n  if (typeof a === 'object' && 'lat' in a) {\n    return new LatLon(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);\n  }\n  if (b === undefined) {\n    return null;\n  }\n  return new LatLon(a, b, c);\n};\n\n// Initialise without requiring new keyword\nexport {noNew as latLon};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/LatLon.js\n **/","/*\n * Point is a helper class for ensuring consistent world positions.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/Point.js\n */\n\nclass Point {\n  constructor(x, y, round) {\n    this.x = (round ? Math.round(x) : x);\n    this.y = (round ? Math.round(y) : y);\n  }\n\n  clone() {\n    return new Point(this.x, this.y);\n  }\n\n  // Non-destructive\n  add(point) {\n    return this.clone()._add(_point(point));\n  }\n\n  // Destructive\n  _add(point) {\n    this.x += point.x;\n    this.y += point.y;\n    return this;\n  }\n\n  // Non-destructive\n  subtract(point) {\n    return this.clone()._subtract(_point(point));\n  }\n\n  // Destructive\n  _subtract(point) {\n    this.x -= point.x;\n    this.y -= point.y;\n    return this;\n  }\n}\n\nexport default Point;\n\n// Accepts (point), ([x, y]) and (x, y, round)\nvar _point = function(x, y, round) {\n  if (x instanceof Point) {\n    return x;\n  }\n  if (Array.isArray(x)) {\n    return new Point(x[0], x[1]);\n  }\n  if (x === undefined || x === null) {\n    return x;\n  }\n  return new Point(x, y, round);\n};\n\n// Initialise without requiring new keyword\nexport {_point as point};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/Point.js\n **/","import EventEmitter from 'eventemitter3';\nimport extend from 'lodash.assign';\nimport shortid from 'shortid';\nimport THREE from 'three';\nimport Scene from '../engine/Scene';\nimport {CSS3DObject} from '../vendor/CSS3DRenderer';\nimport {CSS2DObject} from '../vendor/CSS2DRenderer';\n\n// TODO: Make sure nothing is left behind in the heap after calling destroy()\n\n// TODO: Need a single move method that handles moving all the various object\n// layers so that the DOM layers stay in sync with the 3D layer\n\n// TODO: Double check that objects within the _object3D Object3D parent are frustum\n// culled even if the layer position stays at the default (0,0,0) and the child\n// objects are positioned much further away\n//\n// Or does the layer being at (0,0,0) prevent the child objects from being\n// culled because the layer parent is effectively always in view even if the\n// child is actually out of camera\n\nclass Layer extends EventEmitter {\n  constructor(options) {\n    super();\n\n    var defaults = {\n      id: shortid.generate(),\n      output: true,\n      outputToScene: true\n    };\n\n    this._options = extend({}, defaults, options);\n\n    if (this.isOutput()) {\n      this._object3D = new THREE.Object3D();\n\n      this._dom3D = document.createElement('div');\n      this._domObject3D = new CSS3DObject(this._dom3D);\n\n      this._dom2D = document.createElement('div');\n      this._domObject2D = new CSS2DObject(this._dom2D);\n    }\n  }\n\n  // Add THREE object directly to layer\n  add(object) {\n    this._object3D.add(object);\n  }\n\n  // Remove THREE object from to layer\n  remove(object) {\n    this._object3D.remove(object);\n  }\n\n  addDOM3D(object) {\n    this._domObject3D.add(object);\n  }\n\n  removeDOM3D(object) {\n    this._domObject3D.remove(object);\n  }\n\n  addDOM2D(object) {\n    this._domObject2D.add(object);\n  }\n\n  removeDOM2D(object) {\n    this._domObject2D.remove(object);\n  }\n\n  // Add layer to world instance and store world reference\n  addTo(world) {\n    return world.addLayer(this);\n  }\n\n  // Internal method called by World.addLayer to actually add the layer\n  _addToWorld(world) {\n    this._world = world;\n\n    return new Promise((resolve, reject) => {\n      this._onAdd(world).then(() => {\n        this.emit('added');\n        resolve(this);\n      }).catch(reject);\n    });\n  }\n\n  // Must return a promise\n  _onAdd(world) {\n    return Promise.resolve(this);\n  }\n\n  getPickingId() {\n    if (this._world._engine._picking) {\n      return this._world._engine._picking.getNextId();\n    }\n\n    return false;\n  }\n\n  // TODO: Tidy this up and don't access so many private properties to work\n  addToPicking(object) {\n    if (!this._world._engine._picking) {\n      return;\n    }\n\n    this._world._engine._picking.add(object);\n  }\n\n  removeFromPicking(object) {\n    if (!this._world._engine._picking) {\n      return;\n    }\n\n    this._world._engine._picking.remove(object);\n  }\n\n  isOutput() {\n    return this._options.output;\n  }\n\n  isOutputToScene() {\n    return this._options.outputToScene;\n  }\n\n  // TODO: Also hide any attached DOM layers\n  hide() {\n    this._object3D.visible = false;\n\n    if (this._pickingMesh) {\n      this._pickingMesh.visible = false;\n    }\n  }\n\n  // TODO: Also show any attached DOM layers\n  show() {\n    this._object3D.visible = true;\n\n    if (this._pickingMesh) {\n      this._pickingMesh.visible = true;\n    }\n  }\n\n  // Destroys the layer and removes it from the scene and memory\n  destroy() {\n    if (this._object3D && this._object3D.children) {\n      // Remove everything else in the layer\n      var child;\n      for (var i = this._object3D.children.length - 1; i >= 0; i--) {\n        child = this._object3D.children[i];\n\n        if (!child) {\n          continue;\n        }\n\n        this.remove(child);\n\n        if (child.geometry) {\n          // Dispose of mesh and materials\n          child.geometry.dispose();\n          child.geometry = null;\n        }\n\n        if (child.material) {\n          if (child.material.map) {\n            child.material.map.dispose();\n            child.material.map = null;\n          }\n\n          child.material.dispose();\n          child.material = null;\n        }\n      }\n    }\n\n    if (this._domObject3D && this._domObject3D.children) {\n      // Remove everything else in the layer\n      var child;\n      for (var i = this._domObject3D.children.length - 1; i >= 0; i--) {\n        child = this._domObject3D.children[i];\n\n        if (!child) {\n          continue;\n        }\n\n        this.removeDOM3D(child);\n      }\n    }\n\n    if (this._domObject2D && this._domObject2D.children) {\n      // Remove everything else in the layer\n      var child;\n      for (var i = this._domObject2D.children.length - 1; i >= 0; i--) {\n        child = this._domObject2D.children[i];\n\n        if (!child) {\n          continue;\n        }\n\n        this.removeDOM2D(child);\n      }\n    }\n\n    this._domObject3D = null;\n    this._domObject2D = null;\n\n    this._world = null;\n    this._object3D = null;\n  }\n}\n\nexport default Layer;\n\nvar noNew = function(options) {\n  return new Layer(options);\n};\n\nexport {noNew as layer};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/Layer.js\n **/","'use strict';\n\nvar has = Object.prototype.hasOwnProperty;\n\n//\n// We store our EE objects in a plain object whose properties are event names.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// `~` to make sure that the built-in object properties are not overridden or\n// used as an attack vector.\n// We also assume that `Object.create(null)` is available when the event name\n// is an ES6 Symbol.\n//\nvar prefix = typeof Object.create !== 'function' ? '~' : false;\n\n/**\n * Representation of a single EventEmitter function.\n *\n * @param {Function} fn Event handler to be called.\n * @param {Mixed} context Context for function execution.\n * @param {Boolean} [once=false] Only emit once\n * @api private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Minimal EventEmitter interface that is molded against the Node.js\n * EventEmitter interface.\n *\n * @constructor\n * @api public\n */\nfunction EventEmitter() { /* Nothing to set */ }\n\n/**\n * Hold the assigned EventEmitters by name.\n *\n * @type {Object}\n * @private\n */\nEventEmitter.prototype._events = undefined;\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @api public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var events = this._events\n    , names = []\n    , name;\n\n  if (!events) return names;\n\n  for (name in events) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return a list of assigned event listeners.\n *\n * @param {String} event The events that should be listed.\n * @param {Boolean} exists We only need to know if there are listeners.\n * @returns {Array|Boolean}\n * @api public\n */\nEventEmitter.prototype.listeners = function listeners(event, exists) {\n  var evt = prefix ? prefix + event : event\n    , available = this._events && this._events[evt];\n\n  if (exists) return !!available;\n  if (!available) return [];\n  if (available.fn) return [available.fn];\n\n  for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {\n    ee[i] = available[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Emit an event to all registered event listeners.\n *\n * @param {String} event The name of the event.\n * @returns {Boolean} Indication if we've emitted an event.\n * @api public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events || !this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if ('function' === typeof listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Register a new EventListener for the given event.\n *\n * @param {String} event Name of the event.\n * @param {Function} fn Callback function.\n * @param {Mixed} [context=this] The context of the function.\n * @api public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  var listener = new EE(fn, context || this)\n    , evt = prefix ? prefix + event : event;\n\n  if (!this._events) this._events = prefix ? {} : Object.create(null);\n  if (!this._events[evt]) this._events[evt] = listener;\n  else {\n    if (!this._events[evt].fn) this._events[evt].push(listener);\n    else this._events[evt] = [\n      this._events[evt], listener\n    ];\n  }\n\n  return this;\n};\n\n/**\n * Add an EventListener that's only called once.\n *\n * @param {String} event Name of the event.\n * @param {Function} fn Callback function.\n * @param {Mixed} [context=this] The context of the function.\n * @api public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  var listener = new EE(fn, context || this, true)\n    , evt = prefix ? prefix + event : event;\n\n  if (!this._events) this._events = prefix ? {} : Object.create(null);\n  if (!this._events[evt]) this._events[evt] = listener;\n  else {\n    if (!this._events[evt].fn) this._events[evt].push(listener);\n    else this._events[evt] = [\n      this._events[evt], listener\n    ];\n  }\n\n  return this;\n};\n\n/**\n * Remove event listeners.\n *\n * @param {String} event The event we want to remove.\n * @param {Function} fn The listener that we need to find.\n * @param {Mixed} context Only remove listeners matching this context.\n * @param {Boolean} once Only remove once listeners.\n * @api public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events || !this._events[evt]) return this;\n\n  var listeners = this._events[evt]\n    , events = [];\n\n  if (fn) {\n    if (listeners.fn) {\n      if (\n           listeners.fn !== fn\n        || (once && !listeners.once)\n        || (context && listeners.context !== context)\n      ) {\n        events.push(listeners);\n      }\n    } else {\n      for (var i = 0, length = listeners.length; i < length; i++) {\n        if (\n             listeners[i].fn !== fn\n          || (once && !listeners[i].once)\n          || (context && listeners[i].context !== context)\n        ) {\n          events.push(listeners[i]);\n        }\n      }\n    }\n  }\n\n  //\n  // Reset the array, or remove it completely if we have no more listeners.\n  //\n  if (events.length) {\n    this._events[evt] = events.length === 1 ? events[0] : events;\n  } else {\n    delete this._events[evt];\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners or only the listeners for the specified event.\n *\n * @param {String} event The event want to remove all listeners for.\n * @api public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  if (!this._events) return this;\n\n  if (event) delete this._events[prefix ? prefix + event : event];\n  else this._events = prefix ? {} : Object.create(null);\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// This function doesn't apply anymore.\n//\nEventEmitter.prototype.setMaxListeners = function setMaxListeners() {\n  return this;\n};\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/eventemitter3/index.js\n ** module id = 5\n ** module chunks = 0\n **/","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\nvar keys = require('lodash.keys'),\n    rest = require('lodash.rest');\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */\nvar nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : source[key];\n\n    assignValue(object, key, newValue);\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return rest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Gets the \"length\" property value of `object`.\n *\n * **Note:** This function is used to avoid a\n * [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) that affects\n * Safari on at least iOS 8.1-8.3 ARM64.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {*} Returns the \"length\" value.\n */\nvar getLength = baseProperty('length');\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'user': 'fred' };\n * var other = { 'user': 'fred' };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(getLength(value)) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This function is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length,\n *  else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Assigns own enumerable string keyed properties of source objects to the\n * destination object. Source objects are applied from left to right.\n * Subsequent sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object` and is loosely based on\n * [`Object.assign`](https://mdn.io/Object/assign).\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assignIn\n * @example\n *\n * function Foo() {\n *   this.c = 3;\n * }\n *\n * function Bar() {\n *   this.e = 5;\n * }\n *\n * Foo.prototype.d = 4;\n * Bar.prototype.f = 6;\n *\n * _.assign({ 'a': 1 }, new Foo, new Bar);\n * // => { 'a': 1, 'c': 3, 'e': 5 }\n */\nvar assign = createAssigner(function(object, source) {\n  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {\n    copyObject(source, keys(source), object);\n    return;\n  }\n  for (var key in source) {\n    if (hasOwnProperty.call(source, key)) {\n      assignValue(object, key, source[key]);\n    }\n  }\n});\n\nmodule.exports = assign;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lodash.assign/index.js\n ** module id = 6\n ** module chunks = 0\n **/","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    stringTag = '[object String]';\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetPrototype = Object.getPrototypeOf,\n    nativeKeys = Object.keys;\n\n/**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHas(object, key) {\n  // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`,\n  // that are composed entirely of index properties, return `false` for\n  // `hasOwnProperty` checks of them.\n  return hasOwnProperty.call(object, key) ||\n    (typeof object == 'object' && key in object && getPrototype(object) === null);\n}\n\n/**\n * The base implementation of `_.keys` which doesn't skip the constructor\n * property of prototypes or treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  return nativeKeys(Object(object));\n}\n\n/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\n/**\n * Gets the \"length\" property value of `object`.\n *\n * **Note:** This function is used to avoid a\n * [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) that affects\n * Safari on at least iOS 8.1-8.3 ARM64.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {*} Returns the \"length\" value.\n */\nvar getLength = baseProperty('length');\n\n/**\n * Gets the `[[Prototype]]` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {null|Object} Returns the `[[Prototype]]`.\n */\nfunction getPrototype(value) {\n  return nativeGetPrototype(Object(value));\n}\n\n/**\n * Creates an array of index keys for `object` values of arrays,\n * `arguments` objects, and strings, otherwise `null` is returned.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array|null} Returns index keys, else `null`.\n */\nfunction indexKeys(object) {\n  var length = object ? object.length : undefined;\n  if (isLength(length) &&\n      (isArray(object) || isString(object) || isArguments(object))) {\n    return baseTimes(length, String);\n  }\n  return null;\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 incorrectly makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @type {Function}\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(getLength(value)) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This function is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length,\n *  else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n  return typeof value == 'string' ||\n    (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);\n}\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  var isProto = isPrototype(object);\n  if (!(isProto || isArrayLike(object))) {\n    return baseKeys(object);\n  }\n  var indexes = indexKeys(object),\n      skipIndexes = !!indexes,\n      result = indexes || [],\n      length = result.length;\n\n  for (var key in object) {\n    if (baseHas(object, key) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length))) &&\n        !(isProto && key == 'constructor')) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = keys;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lodash.keys/index.js\n ** module id = 7\n ** module chunks = 0\n **/","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308,\n    NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  var length = args.length;\n  switch (length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Creates a function that invokes `func` with the `this` binding of the\n * created function and arguments from `start` and beyond provided as\n * an array.\n *\n * **Note:** This method is based on the\n * [rest parameter](https://mdn.io/rest_parameters).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.rest(function(what, names) {\n *   return what + ' ' + _.initial(names).join(', ') +\n *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n * });\n *\n * say('hello', 'fred', 'barney', 'pebbles');\n * // => 'hello fred, barney, & pebbles'\n */\nfunction rest(func, start) {\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  start = nativeMax(start === undefined ? (func.length - 1) : toInteger(start), 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    switch (start) {\n      case 0: return func.call(this, array);\n      case 1: return func.call(this, args[0], array);\n      case 2: return func.call(this, args[0], args[1], array);\n    }\n    var otherArgs = Array(start + 1);\n    index = -1;\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This function is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = isFunction(value.valueOf) ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = rest;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lodash.rest/index.js\n ** module id = 8\n ** module chunks = 0\n **/","'use strict';\nmodule.exports = require('./lib/index');\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/index.js\n ** module id = 9\n ** module chunks = 0\n **/","'use strict';\n\nvar alphabet = require('./alphabet');\nvar encode = require('./encode');\nvar decode = require('./decode');\nvar isValid = require('./is-valid');\n\n// Ignore all milliseconds before a certain time to reduce the size of the date entropy without sacrificing uniqueness.\n// This number should be updated every year or so to keep the generated id short.\n// To regenerate `new Date() - 0` and bump the version. Always bump the version!\nvar REDUCE_TIME = 1459707606518;\n\n// don't change unless we change the algos or REDUCE_TIME\n// must be an integer and less than 16\nvar version = 6;\n\n// if you are using cluster or multiple servers use this to make each instance\n// has a unique value for worker\n// Note: I don't know if this is automatically set when using third\n// party cluster solutions such as pm2.\nvar clusterWorkerId = require('./util/cluster-worker-id') || 0;\n\n// Counter is used when shortid is called multiple times in one second.\nvar counter;\n\n// Remember the last time shortid was called in case counter is needed.\nvar previousSeconds;\n\n/**\n * Generate unique id\n * Returns string id\n */\nfunction generate() {\n\n    var str = '';\n\n    var seconds = Math.floor((Date.now() - REDUCE_TIME) * 0.001);\n\n    if (seconds === previousSeconds) {\n        counter++;\n    } else {\n        counter = 0;\n        previousSeconds = seconds;\n    }\n\n    str = str + encode(alphabet.lookup, version);\n    str = str + encode(alphabet.lookup, clusterWorkerId);\n    if (counter > 0) {\n        str = str + encode(alphabet.lookup, counter);\n    }\n    str = str + encode(alphabet.lookup, seconds);\n\n    return str;\n}\n\n\n/**\n * Set the seed.\n * Highly recommended if you don't want people to try to figure out your id schema.\n * exposed as shortid.seed(int)\n * @param seed Integer value to seed the random alphabet.  ALWAYS USE THE SAME SEED or you might get overlaps.\n */\nfunction seed(seedValue) {\n    alphabet.seed(seedValue);\n    return module.exports;\n}\n\n/**\n * Set the cluster worker or machine id\n * exposed as shortid.worker(int)\n * @param workerId worker must be positive integer.  Number less than 16 is recommended.\n * returns shortid module so it can be chained.\n */\nfunction worker(workerId) {\n    clusterWorkerId = workerId;\n    return module.exports;\n}\n\n/**\n *\n * sets new characters to use in the alphabet\n * returns the shuffled alphabet\n */\nfunction characters(newCharacters) {\n    if (newCharacters !== undefined) {\n        alphabet.characters(newCharacters);\n    }\n\n    return alphabet.shuffled();\n}\n\n\n// Export all other functions as properties of the generate function\nmodule.exports = generate;\nmodule.exports.generate = generate;\nmodule.exports.seed = seed;\nmodule.exports.worker = worker;\nmodule.exports.characters = characters;\nmodule.exports.decode = decode;\nmodule.exports.isValid = isValid;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/index.js\n ** module id = 10\n ** module chunks = 0\n **/","'use strict';\n\nvar randomFromSeed = require('./random/random-from-seed');\n\nvar ORIGINAL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';\nvar alphabet;\nvar previousSeed;\n\nvar shuffled;\n\nfunction reset() {\n    shuffled = false;\n}\n\nfunction setCharacters(_alphabet_) {\n    if (!_alphabet_) {\n        if (alphabet !== ORIGINAL) {\n            alphabet = ORIGINAL;\n            reset();\n        }\n        return;\n    }\n\n    if (_alphabet_ === alphabet) {\n        return;\n    }\n\n    if (_alphabet_.length !== ORIGINAL.length) {\n        throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. You submitted ' + _alphabet_.length + ' characters: ' + _alphabet_);\n    }\n\n    var unique = _alphabet_.split('').filter(function(item, ind, arr){\n       return ind !== arr.lastIndexOf(item);\n    });\n\n    if (unique.length) {\n        throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. These characters were not unique: ' + unique.join(', '));\n    }\n\n    alphabet = _alphabet_;\n    reset();\n}\n\nfunction characters(_alphabet_) {\n    setCharacters(_alphabet_);\n    return alphabet;\n}\n\nfunction setSeed(seed) {\n    randomFromSeed.seed(seed);\n    if (previousSeed !== seed) {\n        reset();\n        previousSeed = seed;\n    }\n}\n\nfunction shuffle() {\n    if (!alphabet) {\n        setCharacters(ORIGINAL);\n    }\n\n    var sourceArray = alphabet.split('');\n    var targetArray = [];\n    var r = randomFromSeed.nextValue();\n    var characterIndex;\n\n    while (sourceArray.length > 0) {\n        r = randomFromSeed.nextValue();\n        characterIndex = Math.floor(r * sourceArray.length);\n        targetArray.push(sourceArray.splice(characterIndex, 1)[0]);\n    }\n    return targetArray.join('');\n}\n\nfunction getShuffled() {\n    if (shuffled) {\n        return shuffled;\n    }\n    shuffled = shuffle();\n    return shuffled;\n}\n\n/**\n * lookup shuffled letter\n * @param index\n * @returns {string}\n */\nfunction lookup(index) {\n    var alphabetShuffled = getShuffled();\n    return alphabetShuffled[index];\n}\n\nmodule.exports = {\n    characters: characters,\n    seed: setSeed,\n    lookup: lookup,\n    shuffled: getShuffled\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/alphabet.js\n ** module id = 11\n ** module chunks = 0\n **/","'use strict';\n\n// Found this seed-based random generator somewhere\n// Based on The Central Randomizer 1.3 (C) 1997 by Paul Houle (houle@msc.cornell.edu)\n\nvar seed = 1;\n\n/**\n * return a random number based on a seed\n * @param seed\n * @returns {number}\n */\nfunction getNextValue() {\n    seed = (seed * 9301 + 49297) % 233280;\n    return seed/(233280.0);\n}\n\nfunction setSeed(_seed_) {\n    seed = _seed_;\n}\n\nmodule.exports = {\n    nextValue: getNextValue,\n    seed: setSeed\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/random/random-from-seed.js\n ** module id = 12\n ** module chunks = 0\n **/","'use strict';\n\nvar randomByte = require('./random/random-byte');\n\nfunction encode(lookup, number) {\n    var loopCounter = 0;\n    var done;\n\n    var str = '';\n\n    while (!done) {\n        str = str + lookup( ( (number >> (4 * loopCounter)) & 0x0f ) | randomByte() );\n        done = number < (Math.pow(16, loopCounter + 1 ) );\n        loopCounter++;\n    }\n    return str;\n}\n\nmodule.exports = encode;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/encode.js\n ** module id = 13\n ** module chunks = 0\n **/","'use strict';\n\nvar crypto = typeof window === 'object' && (window.crypto || window.msCrypto); // IE 11 uses window.msCrypto\n\nfunction randomByte() {\n    if (!crypto || !crypto.getRandomValues) {\n        return Math.floor(Math.random() * 256) & 0x30;\n    }\n    var dest = new Uint8Array(1);\n    crypto.getRandomValues(dest);\n    return dest[0] & 0x30;\n}\n\nmodule.exports = randomByte;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/random/random-byte-browser.js\n ** module id = 14\n ** module chunks = 0\n **/","'use strict';\nvar alphabet = require('./alphabet');\n\n/**\n * Decode the id to get the version and worker\n * Mainly for debugging and testing.\n * @param id - the shortid-generated id.\n */\nfunction decode(id) {\n    var characters = alphabet.shuffled();\n    return {\n        version: characters.indexOf(id.substr(0, 1)) & 0x0f,\n        worker: characters.indexOf(id.substr(1, 1)) & 0x0f\n    };\n}\n\nmodule.exports = decode;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/decode.js\n ** module id = 15\n ** module chunks = 0\n **/","'use strict';\nvar alphabet = require('./alphabet');\n\nfunction isShortId(id) {\n    if (!id || typeof id !== 'string' || id.length < 6 ) {\n        return false;\n    }\n\n    var characters = alphabet.characters();\n    var len = id.length;\n    for(var i = 0; i < len;i++) {\n        if (characters.indexOf(id[i]) === -1) {\n            return false;\n        }\n    }\n    return true;\n}\n\nmodule.exports = isShortId;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/is-valid.js\n ** module id = 16\n ** module chunks = 0\n **/","'use strict';\n\nmodule.exports = 0;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/shortid/lib/util/cluster-worker-id-browser.js\n ** module id = 17\n ** module chunks = 0\n **/","module.exports = __WEBPACK_EXTERNAL_MODULE_18__;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** external \"THREE\"\n ** module id = 18\n ** module chunks = 0\n **/","import THREE from 'three';\n\n// This can be imported from anywhere and will still reference the same scene,\n// though there is a helper reference in Engine.scene\n\nexport default (function() {\n  var scene = new THREE.Scene();\n\n  // TODO: Re-enable when this works with the skybox\n  // scene.fog = new THREE.Fog(0xffffff, 1, 15000);\n  return scene;\n})();\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/engine/Scene.js\n **/","// jscs:disable\n/* eslint-disable */\n\n/**\n * Based on http://www.emagix.net/academic/mscs-project/item/camera-sync-with-css3-and-webgl-threejs\n * @author mrdoob / http://mrdoob.com/\n */\n\nimport THREE from 'three';\n\nvar CSS3DObject = function ( element ) {\n\n\tTHREE.Object3D.call( this );\n\n\tthis.element = element;\n\tthis.element.style.position = 'absolute';\n\n\tthis.addEventListener( 'removed', function ( event ) {\n\n\t\tif ( this.element.parentNode !== null ) {\n\n\t\t\tthis.element.parentNode.removeChild( this.element );\n\n\t\t}\n\n\t} );\n\n};\n\nCSS3DObject.prototype = Object.create( THREE.Object3D.prototype );\nCSS3DObject.prototype.constructor = CSS3DObject;\n\nvar CSS3DSprite = function ( element ) {\n\n\tCSS3DObject.call( this, element );\n\n};\n\nCSS3DSprite.prototype = Object.create( CSS3DObject.prototype );\nCSS3DSprite.prototype.constructor = CSS3DSprite;\n\n//\n\nvar CSS3DRenderer = function () {\n\n\tconsole.log( 'THREE.CSS3DRenderer', THREE.REVISION );\n\n\tvar _width, _height;\n\tvar _widthHalf, _heightHalf;\n\n\tvar matrix = new THREE.Matrix4();\n\n\tvar cache = {\n\t\tcamera: { fov: 0, style: '' },\n\t\tobjects: {}\n\t};\n\n\tvar domElement = document.createElement( 'div' );\n\tdomElement.style.overflow = 'hidden';\n\n\tdomElement.style.WebkitTransformStyle = 'preserve-3d';\n\tdomElement.style.MozTransformStyle = 'preserve-3d';\n\tdomElement.style.oTransformStyle = 'preserve-3d';\n\tdomElement.style.transformStyle = 'preserve-3d';\n\n\tthis.domElement = domElement;\n\n\tvar cameraElement = document.createElement( 'div' );\n\n\tcameraElement.style.WebkitTransformStyle = 'preserve-3d';\n\tcameraElement.style.MozTransformStyle = 'preserve-3d';\n\tcameraElement.style.oTransformStyle = 'preserve-3d';\n\tcameraElement.style.transformStyle = 'preserve-3d';\n\n\tdomElement.appendChild( cameraElement );\n\n\tthis.setClearColor = function () {};\n\n\tthis.getSize = function() {\n\n\t\treturn {\n\t\t\twidth: _width,\n\t\t\theight: _height\n\t\t};\n\n\t};\n\n\tthis.setSize = function ( width, height ) {\n\n\t\t_width = width;\n\t\t_height = height;\n\n\t\t_widthHalf = _width / 2;\n\t\t_heightHalf = _height / 2;\n\n\t\tdomElement.style.width = width + 'px';\n\t\tdomElement.style.height = height + 'px';\n\n\t\tcameraElement.style.width = width + 'px';\n\t\tcameraElement.style.height = height + 'px';\n\n\t};\n\n\tvar epsilon = function ( value ) {\n\n\t\treturn Math.abs( value ) < Number.EPSILON ? 0 : value;\n\n\t};\n\n\tvar getCameraCSSMatrix = function ( matrix ) {\n\n\t\tvar elements = matrix.elements;\n\n\t\treturn 'matrix3d(' +\n\t\t\tepsilon( elements[ 0 ] ) + ',' +\n\t\t\tepsilon( - elements[ 1 ] ) + ',' +\n\t\t\tepsilon( elements[ 2 ] ) + ',' +\n\t\t\tepsilon( elements[ 3 ] ) + ',' +\n\t\t\tepsilon( elements[ 4 ] ) + ',' +\n\t\t\tepsilon( - elements[ 5 ] ) + ',' +\n\t\t\tepsilon( elements[ 6 ] ) + ',' +\n\t\t\tepsilon( elements[ 7 ] ) + ',' +\n\t\t\tepsilon( elements[ 8 ] ) + ',' +\n\t\t\tepsilon( - elements[ 9 ] ) + ',' +\n\t\t\tepsilon( elements[ 10 ] ) + ',' +\n\t\t\tepsilon( elements[ 11 ] ) + ',' +\n\t\t\tepsilon( elements[ 12 ] ) + ',' +\n\t\t\tepsilon( - elements[ 13 ] ) + ',' +\n\t\t\tepsilon( elements[ 14 ] ) + ',' +\n\t\t\tepsilon( elements[ 15 ] ) +\n\t\t')';\n\n\t};\n\n\tvar getObjectCSSMatrix = function ( matrix ) {\n\n\t\tvar elements = matrix.elements;\n\n\t\treturn 'translate3d(-50%,-50%,0) matrix3d(' +\n\t\t\tepsilon( elements[ 0 ] ) + ',' +\n\t\t\tepsilon( elements[ 1 ] ) + ',' +\n\t\t\tepsilon( elements[ 2 ] ) + ',' +\n\t\t\tepsilon( elements[ 3 ] ) + ',' +\n\t\t\tepsilon( - elements[ 4 ] ) + ',' +\n\t\t\tepsilon( - elements[ 5 ] ) + ',' +\n\t\t\tepsilon( - elements[ 6 ] ) + ',' +\n\t\t\tepsilon( - elements[ 7 ] ) + ',' +\n\t\t\tepsilon( elements[ 8 ] ) + ',' +\n\t\t\tepsilon( elements[ 9 ] ) + ',' +\n\t\t\tepsilon( elements[ 10 ] ) + ',' +\n\t\t\tepsilon( elements[ 11 ] ) + ',' +\n\t\t\tepsilon( elements[ 12 ] ) + ',' +\n\t\t\tepsilon( elements[ 13 ] ) + ',' +\n\t\t\tepsilon( elements[ 14 ] ) + ',' +\n\t\t\tepsilon( elements[ 15 ] ) +\n\t\t')';\n\n\t};\n\n\tvar renderObject = function ( object, camera ) {\n\n\t\tif ( object instanceof CSS3DObject ) {\n\n\t\t\tvar style;\n\n\t\t\tif ( object instanceof CSS3DSprite ) {\n\n\t\t\t\t// http://swiftcoder.wordpress.com/2008/11/25/constructing-a-billboard-matrix/\n\n\t\t\t\tmatrix.copy( camera.matrixWorldInverse );\n\t\t\t\tmatrix.transpose();\n\t\t\t\tmatrix.copyPosition( object.matrixWorld );\n\t\t\t\tmatrix.scale( object.scale );\n\n\t\t\t\tmatrix.elements[ 3 ] = 0;\n\t\t\t\tmatrix.elements[ 7 ] = 0;\n\t\t\t\tmatrix.elements[ 11 ] = 0;\n\t\t\t\tmatrix.elements[ 15 ] = 1;\n\n\t\t\t\tstyle = getObjectCSSMatrix( matrix );\n\n\t\t\t} else {\n\n\t\t\t\tstyle = getObjectCSSMatrix( object.matrixWorld );\n\n\t\t\t}\n\n\t\t\tvar element = object.element;\n\t\t\tvar cachedStyle = cache.objects[ object.id ];\n\n\t\t\tif ( cachedStyle === undefined || cachedStyle !== style ) {\n\n\t\t\t\telement.style.WebkitTransform = style;\n\t\t\t\telement.style.MozTransform = style;\n\t\t\t\telement.style.oTransform = style;\n\t\t\t\telement.style.transform = style;\n\n\t\t\t\tcache.objects[ object.id ] = style;\n\n\t\t\t}\n\n\t\t\tif ( element.parentNode !== cameraElement ) {\n\n\t\t\t\tcameraElement.appendChild( element );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfor ( var i = 0, l = object.children.length; i < l; i ++ ) {\n\n\t\t\trenderObject( object.children[ i ], camera );\n\n\t\t}\n\n\t};\n\n\tthis.render = function ( scene, camera ) {\n\n\t\tvar fov = 0.5 / Math.tan( THREE.Math.degToRad( camera.fov * 0.5 ) ) * _height;\n\n\t\tif ( cache.camera.fov !== fov ) {\n\n\t\t\tdomElement.style.WebkitPerspective = fov + 'px';\n\t\t\tdomElement.style.MozPerspective = fov + 'px';\n\t\t\tdomElement.style.oPerspective = fov + 'px';\n\t\t\tdomElement.style.perspective = fov + 'px';\n\n\t\t\tcache.camera.fov = fov;\n\n\t\t}\n\n\t\tscene.updateMatrixWorld();\n\n\t\tif ( camera.parent === null ) camera.updateMatrixWorld();\n\n\t\tcamera.matrixWorldInverse.getInverse( camera.matrixWorld );\n\n\t\tvar style = 'translate3d(0,0,' + fov + 'px)' + getCameraCSSMatrix( camera.matrixWorldInverse ) +\n\t\t\t' translate3d(' + _widthHalf + 'px,' + _heightHalf + 'px, 0)';\n\n\t\tif ( cache.camera.style !== style ) {\n\n\t\t\tcameraElement.style.WebkitTransform = style;\n\t\t\tcameraElement.style.MozTransform = style;\n\t\t\tcameraElement.style.oTransform = style;\n\t\t\tcameraElement.style.transform = style;\n\n\t\t\tcache.camera.style = style;\n\n\t\t}\n\n\t\trenderObject( scene, camera );\n\n\t};\n\n};\n\nexport {CSS3DObject as CSS3DObject};\nexport {CSS3DSprite as CSS3DSprite};\nexport {CSS3DRenderer as CSS3DRenderer};\n\nTHREE.CSS3DObject = CSS3DObject;\nTHREE.CSS3DSprite = CSS3DSprite;\nTHREE.CSS3DRenderer = CSS3DRenderer;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/vendor/CSS3DRenderer.js\n **/","// jscs:disable\n/* eslint-disable */\n\n/**\n * @author mrdoob / http://mrdoob.com/\n */\n\nimport THREE from 'three';\n\nvar CSS2DObject = function ( element ) {\n\n\tTHREE.Object3D.call( this );\n\n\tthis.element = element;\n\tthis.element.style.position = 'absolute';\n\n\tthis.addEventListener( 'removed', function ( event ) {\n\n\t\tif ( this.element.parentNode !== null ) {\n\n\t\t\tthis.element.parentNode.removeChild( this.element );\n\n\t\t}\n\n\t} );\n\n};\n\nCSS2DObject.prototype = Object.create( THREE.Object3D.prototype );\nCSS2DObject.prototype.constructor = CSS2DObject;\n\n//\n\nvar CSS2DRenderer = function () {\n\n\tconsole.log( 'THREE.CSS2DRenderer', THREE.REVISION );\n\n\tvar _width, _height;\n\tvar _widthHalf, _heightHalf;\n\n\tvar vector = new THREE.Vector3();\n\tvar viewMatrix = new THREE.Matrix4();\n\tvar viewProjectionMatrix = new THREE.Matrix4();\n\n\tvar frustum = new THREE.Frustum();\n\n\tvar domElement = document.createElement( 'div' );\n\tdomElement.style.overflow = 'hidden';\n\n\tthis.domElement = domElement;\n\n\tthis.setSize = function ( width, height ) {\n\n\t\t_width = width;\n\t\t_height = height;\n\n\t\t_widthHalf = _width / 2;\n\t\t_heightHalf = _height / 2;\n\n\t\tdomElement.style.width = width + 'px';\n\t\tdomElement.style.height = height + 'px';\n\n\t};\n\n\tvar renderObject = function ( object, camera ) {\n\n\t\tif ( object instanceof CSS2DObject ) {\n\n\t\t\tvector.setFromMatrixPosition( object.matrixWorld );\n\t\t\tvector.applyProjection( viewProjectionMatrix );\n\n\t\t\tvar element = object.element;\n\t\t\tvar style = 'translate(-50%,-50%) translate(' + ( vector.x * _widthHalf + _widthHalf ) + 'px,' + ( - vector.y * _heightHalf + _heightHalf ) + 'px)';\n\n\t\t\telement.style.WebkitTransform = style;\n\t\t\telement.style.MozTransform = style;\n\t\t\telement.style.oTransform = style;\n\t\t\telement.style.transform = style;\n\n\t\t\tif ( element.parentNode !== domElement ) {\n\n\t\t\t\tdomElement.appendChild( element );\n\n\t\t\t}\n\n\t\t\t// Hide if outside view frustum\n\t\t\tif (!frustum.containsPoint(object.position)) {\n\t\t\t\telement.style.display = 'none';\n\t\t\t} else {\n\t\t\t\telement.style.display = 'block';\n\t\t\t}\n\n\t\t}\n\n\t\tfor ( var i = 0, l = object.children.length; i < l; i ++ ) {\n\n\t\t\trenderObject( object.children[ i ], camera );\n\n\t\t}\n\n\t};\n\n\tthis.render = function ( scene, camera ) {\n\n\t\tscene.updateMatrixWorld();\n\n\t\tif ( camera.parent === null ) camera.updateMatrixWorld();\n\n\t\tcamera.matrixWorldInverse.getInverse( camera.matrixWorld );\n\n\t\tviewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );\n\t\tviewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, viewMatrix );\n\n\t\tfrustum.setFromMatrix( new THREE.Matrix4().multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse ) );\n\n\t\trenderObject( scene, camera );\n\n\t};\n\n};\n\nexport {CSS2DObject as CSS2DObject};\nexport {CSS2DRenderer as CSS2DRenderer};\n\nTHREE.CSS2DObject = CSS2DObject;\nTHREE.CSS2DRenderer = CSS2DRenderer;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/vendor/CSS2DRenderer.js\n **/","import Layer from './Layer';\nimport extend from 'lodash.assign';\nimport reqwest from 'reqwest';\nimport GeoJSON from '../util/GeoJSON';\nimport Worker from '../util/Worker';\nimport Buffer from '../util/Buffer';\nimport Stringify from '../util/Stringify';\nimport PolygonLayer from './geometry/PolygonLayer';\nimport PolylineLayer from './geometry/PolylineLayer';\nimport PointLayer from './geometry/PointLayer';\nimport {latLon as LatLon} from '../geo/LatLon';\nimport {point as Point} from '../geo/Point';\nimport Geo from '../geo/Geo';\nimport PickingMaterial from '../engine/PickingMaterial';\n\n// TODO: Allow filter method to be run inside a worker to improve performance\n// TODO: Allow onEachFeature method to be run inside a worker to improve performance\n\nclass GeoJSONWorkerLayer extends Layer {\n  constructor(geojson, options) {\n    var defaults = {\n      topojson: false,\n      style: GeoJSON.defaultStyle,\n      onEachFeature: null,\n      onEachFeatureWorker: null,\n      onAddAttributes: null,\n      interactive: false,\n      pointGeometry: null,\n      onClick: null,\n      headers: {}\n    };\n\n    var _options = extend({}, defaults, options);\n\n    if (typeof options.style === 'object') {\n      _options.style = extend({}, defaults.style, options.style);\n    }\n\n    super(_options);\n\n    this._aborted = false;\n    this._geojson = geojson;\n  }\n\n  _onAdd(world) {\n    if (this._options.interactive) {\n      // Worker layer always controls output to add a picking mesh\n      this._pickingMesh = new THREE.Object3D();\n    }\n\n    // Process GeoJSON\n    return this._process(this._geojson);\n  }\n\n  // Use workers to request and process GeoJSON, returning data structure\n  // containing geometry and any supplementary data for output\n  _process(_geojson) {\n    return new Promise((resolve, reject) => {\n      var style = this._options.style;\n\n      // TODO: Convert to buffer and use transferrable objects\n      if (typeof this._options.style === 'function') {\n        style = Stringify.functionToString(this._options.style);\n      }\n\n      var pointGeometry = this._options.pointGeometry;\n\n      // TODO: Convert to buffer and use transferrable objects\n      if (typeof this._options.pointGeometry === 'function') {\n        pointGeometry = Stringify.functionToString(this._options.pointGeometry);\n      }\n\n      var geojson = _geojson;\n      var transferrables = [];\n\n      if (typeof geojson !== 'string') {\n        this._geojson = geojson = Buffer.stringToUint8Array(JSON.stringify(geojson));\n        transferrables.push(geojson.buffer);\n        this._execWorker(geojson, this._options.topojson, this._world._originPoint, style, this._options.interactive, pointGeometry, transferrables).then(() => {\n          resolve();\n        }).catch(reject);\n      } else if (typeof this._options.filter === 'function' || typeof this._options.onEachFeature === 'function') {\n        GeoJSONWorkerLayer.RequestGeoJSON(geojson).then((res) => {\n          // if (this._aborted) {\n          //   resolve();\n          //   return;\n          // }\n\n          var fc = GeoJSON.collectFeatures(res, this._options.topojson);\n          var features = fc.features;\n\n          // Run filter, if provided\n          if (this._options.filter) {\n            fc.features = features.filter(this._options.filter);\n          }\n\n          if (this._options.onEachFeature) {\n            var feature;\n            for (var i = 0; i < features.length; i++) {\n              feature = features[i];\n              this._options.onEachFeature(feature);\n            };\n          }\n\n          this._geojson = geojson = Buffer.stringToUint8Array(JSON.stringify(fc));\n          transferrables.push(geojson.buffer);\n\n          this._execWorker(geojson, false, this._options.headers, this._world._originPoint, style, this._options.interactive, pointGeometry, transferrables).then(() => {\n            resolve();\n          }).catch(reject);\n        });\n      } else {\n        this._execWorker(geojson, this._options.topojson, this._options.headers, this._world._originPoint, style, this._options.interactive, pointGeometry, transferrables).then(() => {\n          resolve();\n        }).catch(reject);\n      }\n    });\n  }\n\n  _execWorker(geojson, topojson, headers, originPoint, style, interactive, pointGeometry, transferrables) {\n    return new Promise((resolve, reject) => {\n      console.time('Worker round trip');\n\n      Worker.exec('GeoJSONWorkerLayer.Process', [geojson, topojson, headers, originPoint, style, interactive, pointGeometry], transferrables).then((results) => {\n        console.timeEnd('Worker round trip');\n\n        // if (this._aborted) {\n        //   resolve();\n        //   return;\n        // }\n\n        var processPromises = [];\n\n        if (results.polygons) {\n          processPromises.push(this._processPolygonResults(results.polygons));\n        }\n\n        if (results.polylines) {\n          processPromises.push(this._processPolylineResults(results.polylines));\n        }\n\n        if (results.points) {\n          processPromises.push(this._processPointResults(results.points));\n        }\n\n        if (processPromises.length > 0) {\n          Promise.all(processPromises).then(() => {\n            resolve();\n          }).catch(reject);\n        } else {\n          resolve();\n        }\n      });\n    });\n  }\n\n  // TODO: Dedupe with polyline method\n  _processPolygonResults(results) {\n    return new Promise((resolve, reject) => {\n      var splitPositions = Buffer.splitFloat32Array(results.attributes.positions);\n      var splitNormals = Buffer.splitFloat32Array(results.attributes.normals);\n      var splitColors = Buffer.splitFloat32Array(results.attributes.colors);\n      var splitTops = Buffer.splitFloat32Array(results.attributes.tops);\n\n      var splitOutlinePositions;\n      var splitOutlineColors;\n\n      if (results.outlineAttributes) {\n        splitOutlinePositions = Buffer.splitFloat32Array(results.outlineAttributes.positions);\n        splitOutlineColors = Buffer.splitFloat32Array(results.outlineAttributes.colors);\n      }\n\n      var splitProperties;\n      if (results.properties) {\n        splitProperties = Buffer.splitUint8Array(results.properties);\n      }\n\n      var flats = results.flats;\n\n      var objects = [];\n      var outlineObjects = [];\n\n      var obj;\n      var pickingId;\n      var pickingIds;\n      var properties;\n\n      var polygonAttributeLengths = {\n        positions: 3,\n        normals: 3,\n        colors: 3,\n        tops: 1\n      };\n\n      var polygonOutlineAttributeLengths = {\n        positions: 3,\n        colors: 3\n      };\n\n      for (var i = 0; i < splitPositions.length; i++) {\n        if (splitProperties && splitProperties[i]) {\n          properties = JSON.parse(Buffer.uint8ArrayToString(splitProperties[i]));\n        } else {\n          properties = {};\n        }\n\n        // WORKERS: obj.attributes should actually an array of polygons for\n        // the feature, though the current logic isn't aware of that\n        obj = {\n          attributes: [{\n            positions: splitPositions[i],\n            normals: splitNormals[i],\n            colors: splitColors[i],\n            tops: splitTops[i]\n          }],\n          properties: properties,\n          flat: flats[i]\n        };\n\n        // WORKERS: If interactive, generate unique ID for each feature, create\n        // the buffer attributes and set up event listeners\n        if (this._options.interactive) {\n          pickingId = this.getPickingId();\n\n          pickingIds = new Float32Array(splitPositions[i].length / 3);\n          pickingIds.fill(pickingId);\n\n          obj.attributes[0].pickingIds = pickingIds;\n\n          polygonAttributeLengths.pickingIds = 1;\n\n          this._addPicking(pickingId, properties);\n        }\n\n        // TODO: Make this specific to polygon attributes\n        if (typeof this._options.onAddAttributes === 'function') {\n          var customAttributes = this._options.onAddAttributes(obj.attributes[0], properties);\n          var customAttribute;\n          for (var key in customAttributes) {\n            customAttribute = customAttributes[key];\n            obj.attributes[0][key] = customAttribute.value;\n            polygonAttributeLengths[key] = customAttribute.length;\n          }\n        }\n\n        objects.push(obj);\n      }\n\n      for (var i = 0; i < splitOutlinePositions.length; i++) {\n        obj = {\n          attributes: [{\n            positions: splitOutlinePositions[i],\n            colors: splitOutlineColors[i]\n          }],\n          flat: true\n        };\n\n        outlineObjects.push(obj);\n      }\n\n      var polygonAttributes = [];\n      var polygonOutlineAttributes = [];\n\n      var polygonFlat = true;\n\n      for (var i = 0; i < objects.length; i++) {\n        obj = objects[i];\n\n        // TODO: Work out why obj.flat is rarely set to something other than\n        // true or false. Potentially undefined.\n        if (polygonFlat && obj.flat === false) {\n          polygonFlat = false;\n        }\n\n        var bufferAttributes = Buffer.mergeAttributes(obj.attributes);\n        polygonAttributes.push(bufferAttributes);\n      };\n\n      for (var i = 0; i < outlineObjects.length; i++) {\n        obj = outlineObjects[i];\n\n        var bufferAttributes = Buffer.mergeAttributes(obj.attributes);\n        polygonOutlineAttributes.push(bufferAttributes);\n      };\n\n      var outputPromises = [];\n\n      var style;\n\n      if (polygonAttributes.length > 0) {\n        var mergedPolygonAttributes = Buffer.mergeAttributes(polygonAttributes);\n\n        // TODO: Make this work when style is a function per feature\n        style = (typeof this._options.style === 'function') ? this._options.style(objects[0]) : this._options.style;\n        style = extend({}, GeoJSON.defaultStyle, style);\n\n        outputPromises.push(this._setPolygonMesh(mergedPolygonAttributes, polygonAttributeLengths, style, polygonFlat));\n      }\n\n      if (polygonOutlineAttributes.length > 0) {\n        var mergedPolygonOutlineAttributes = Buffer.mergeAttributes(polygonOutlineAttributes);\n\n        style = (typeof this._options.style === 'function') ? this._options.style(objects[0]) : this._options.style;\n        style = extend({}, GeoJSON.defaultStyle, style);\n\n        if (style.outlineRenderOrder !== undefined) {\n          style.lineRenderOrder = style.outlineRenderOrder;\n        } else {\n          style.lineRenderOrder = (style.renderOrder) ? style.renderOrder + 1 : 4;\n        }\n\n        if (style.outlineWidth) {\n          style.lineWidth = style.outlineWidth;\n        }\n\n        outputPromises.push(this._setPolylineMesh(mergedPolygonOutlineAttributes, polygonOutlineAttributeLengths, style, true));\n      }\n\n      Promise.all(outputPromises).then((results) => {\n        var [polygonResult, outlineResult] = results;\n\n        if (polygonResult) {\n          this._polygonMesh = polygonResult.mesh;\n          this.add(this._polygonMesh);\n\n          if (polygonResult.pickingMesh) {\n            this._pickingMesh.add(polygonResult.pickingMesh);\n          }\n        }\n\n        if (outlineResult) {\n          this.add(outlineResult.mesh);\n        }\n\n        resolve();\n      }).catch(reject);\n    });\n  }\n\n  // TODO: Dedupe with polygon method\n  _processPolylineResults(results) {\n    return new Promise((resolve, reject) => {\n      var splitPositions = Buffer.splitFloat32Array(results.attributes.positions);\n      var splitColors = Buffer.splitFloat32Array(results.attributes.colors);\n\n      var splitProperties;\n      if (results.properties) {\n        splitProperties = Buffer.splitUint8Array(results.properties);\n      }\n\n      var flats = results.flats;\n\n      var objects = [];\n      var obj;\n      var pickingId;\n      var pickingIds;\n      var properties;\n\n      var polylineAttributeLengths = {\n        positions: 3,\n        colors: 3\n      };\n\n      for (var i = 0; i < splitPositions.length; i++) {\n        if (splitProperties && splitProperties[i]) {\n          properties = JSON.parse(Buffer.uint8ArrayToString(splitProperties[i]));\n        } else {\n          properties = {};\n        }\n\n        // WORKERS: obj.attributes should actually an array of polygons for\n        // the feature, though the current logic isn't aware of that\n        obj = {\n          attributes: [{\n            positions: splitPositions[i],\n            colors: splitColors[i]\n          }],\n          properties: properties,\n          flat: flats[i]\n        };\n\n        // WORKERS: If interactive, generate unique ID for each feature, create\n        // the buffer attributes and set up event listeners\n        if (this._options.interactive) {\n          pickingId = this.getPickingId();\n\n          pickingIds = new Float32Array(splitPositions[i].length / 3);\n          pickingIds.fill(pickingId);\n\n          obj.attributes[0].pickingIds = pickingIds;\n\n          polylineAttributeLengths.pickingIds = 1;\n\n          this._addPicking(pickingId, properties);\n        }\n\n        // TODO: Make this specific to polyline attributes\n        if (typeof this._options.onAddAttributes === 'function') {\n          var customAttributes = this._options.onAddAttributes(obj.attributes[0], properties);\n          var customAttribute;\n          for (var key in customAttributes) {\n            customAttribute = customAttributes[key];\n            obj.attributes[0][key] = customAttribute.value;\n            polylineAttributeLengths[key] = customAttribute.length;\n          }\n        }\n\n        objects.push(obj);\n      }\n\n      var polylineAttributes = [];\n\n      var polylineFlat = true;\n\n      for (var i = 0; i < objects.length; i++) {\n        obj = objects[i];\n\n        if (polylineFlat && !obj.flat) {\n          polylineFlat = false;\n        }\n\n        var bufferAttributes = Buffer.mergeAttributes(obj.attributes);\n        polylineAttributes.push(bufferAttributes);\n      };\n\n      if (polylineAttributes.length > 0) {\n        var mergedPolylineAttributes = Buffer.mergeAttributes(polylineAttributes);\n\n        // TODO: Make this work when style is a function per feature\n        var style = (typeof this._options.style === 'function') ? this._options.style(objects[0]) : this._options.style;\n        style = extend({}, GeoJSON.defaultStyle, style);\n\n        this._setPolylineMesh(mergedPolylineAttributes, polylineAttributeLengths, style, polylineFlat).then((result) => {\n          this._polylineMesh = result.mesh;\n          this.add(this._polylineMesh);\n\n          if (result.pickingMesh) {\n            this._pickingMesh.add(result.pickingMesh);\n          }\n\n          resolve();\n        }).catch(reject);\n      } else {\n        resolve();\n      }\n    });\n  }\n\n  _processPointResults(results) {\n    return new Promise((resolve, reject) => {\n      var splitPositions = Buffer.splitFloat32Array(results.attributes.positions);\n      var splitNormals = Buffer.splitFloat32Array(results.attributes.normals);\n      var splitColors = Buffer.splitFloat32Array(results.attributes.colors);\n\n      var splitProperties;\n      if (results.properties) {\n        splitProperties = Buffer.splitUint8Array(results.properties);\n      }\n\n      var flats = results.flats;\n\n      var objects = [];\n      var obj;\n      var pickingId;\n      var pickingIds;\n      var properties;\n\n      var pointAttributeLengths = {\n        positions: 3,\n        normals: 3,\n        colors: 3\n      };\n\n      for (var i = 0; i < splitPositions.length; i++) {\n        if (splitProperties && splitProperties[i]) {\n          properties = JSON.parse(Buffer.uint8ArrayToString(splitProperties[i]));\n        } else {\n          properties = {};\n        }\n\n        // WORKERS: obj.attributes should actually an array of polygons for\n        // the feature, though the current logic isn't aware of that\n        obj = {\n          attributes: [{\n            positions: splitPositions[i],\n            normals: splitNormals[i],\n            colors: splitColors[i]\n          }],\n          properties: properties,\n          flat: flats[i]\n        };\n\n        // WORKERS: If interactive, generate unique ID for each feature, create\n        // the buffer attributes and set up event listeners\n        if (this._options.interactive) {\n          pickingId = this.getPickingId();\n\n          pickingIds = new Float32Array(splitPositions[i].length / 3);\n          pickingIds.fill(pickingId);\n\n          obj.attributes[0].pickingIds = pickingIds;\n\n          pointAttributeLengths.pickingIds = 1;\n\n          this._addPicking(pickingId, properties);\n        }\n\n        // TODO: Make this specific to polygon attributes\n        if (typeof this._options.onAddAttributes === 'function') {\n          var customAttributes = this._options.onAddAttributes(obj.attributes[0], properties);\n          var customAttribute;\n          for (var key in customAttributes) {\n            customAttribute = customAttributes[key];\n            obj.attributes[0][key] = customAttribute.value;\n            pointAttributeLengths[key] = customAttribute.length;\n          }\n        }\n\n        objects.push(obj);\n      }\n\n      var pointAttributes = [];\n\n      var pointFlat = true;\n\n      for (var i = 0; i < objects.length; i++) {\n        obj = objects[i];\n\n        if (pointFlat && !obj.flat) {\n          pointFlat = false;\n        }\n\n        var bufferAttributes = Buffer.mergeAttributes(obj.attributes);\n        pointAttributes.push(bufferAttributes);\n      };\n\n      if (pointAttributes.length > 0) {\n        var mergedPointAttributes = Buffer.mergeAttributes(pointAttributes);\n\n        // TODO: Make this work when style is a function per feature\n        var style = (typeof this._options.style === 'function') ? this._options.style(objects[0]) : this._options.style;\n        style = extend({}, GeoJSON.defaultStyle, style);\n\n        this._setPointMesh(mergedPointAttributes, pointAttributeLengths, style, pointFlat).then((result) => {\n          this._pointMesh = result.mesh;\n          this.add(this._pointMesh);\n\n          if (result.pickingMesh) {\n            this._pickingMesh.add(result.pickingMesh);\n          }\n\n          resolve();\n        }).catch(reject);\n      } else {\n        resolve();\n      }\n    });\n  }\n\n  // TODO: At some point this needs to return all the features to the main thread\n  // so it can generate meshes and output to the scene, as well as perhaps creating\n  // individual layers / components for each feature to track things like picking\n  // and properties\n  //\n  // TODO: Find a way so the origin point isn't needed to be passed in as it\n  // feels a bit messy and against the idea of a static Geo class\n  //\n  // TODO: Support passing custom geometry for point layers\n  static Process(geojson, topojson, headers, originPoint, _style, _properties, _pointGeometry) {\n    return new Promise((resolve, reject) => {\n      GeoJSONWorkerLayer.ProcessGeoJSON(geojson, headers).then((res) => {\n        // Collects features into a single FeatureCollection\n        //\n        // Also converts TopoJSON to GeoJSON if instructed\n        var geojson = GeoJSON.collectFeatures(res, topojson);\n\n        // TODO: Check that GeoJSON is valid / usable\n\n        var features = geojson.features;\n\n        // TODO: Run filter, if provided (must be static)\n\n        var pointScale;\n        var polygons = [];\n        var polylines = [];\n        var points = [];\n\n        // Deserialise style function if provided\n        if (typeof _style === 'string') {\n          _style = Stringify.stringToFunction(_style);\n        }\n\n        // Assume that a style won't be set per feature\n        var style = _style;\n\n        var pointGeometry;\n        // Deserialise pointGeometry function if provided\n        if (typeof _pointGeometry === 'string') {\n          pointGeometry = Stringify.stringToFunction(_pointGeometry);\n        }\n\n        var feature;\n        for (var i = 0; i < features.length; i++) {\n          feature = features[i];\n\n          var geometry = feature.geometry;\n          var coordinates = (geometry.coordinates) ? geometry.coordinates : null;\n\n          if (!coordinates || !geometry) {\n            return;\n          }\n\n          // Get per-feature style object, if provided\n          if (typeof _style === 'function') {\n            style = extend({}, GeoJSON.defaultStyle, _style(feature));\n            // console.log(feature, style);\n          }\n\n          if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {\n            coordinates = (PolygonLayer.isSingle(coordinates)) ? [coordinates] : coordinates;\n\n            var converted = coordinates.map(_coordinates => {\n              return _coordinates.map(ring => {\n                return ring.map(coordinate => {\n                  return LatLon(coordinate[1], coordinate[0]);\n                });\n              });\n            });\n\n            var point;\n            var projected = converted.map((_coordinates) => {\n              return _coordinates.map((ring) => {\n                return ring.map((latlon) => {\n                  point = Geo.latLonToPoint(latlon)._subtract(originPoint);\n\n                  if (!pointScale) {\n                    pointScale = Geo.pointScale(latlon);\n                  }\n\n                  return point;\n                });\n              });\n            });\n\n            var polygon = {\n              projected: projected,\n              options: {\n                pointScale: pointScale,\n                style: style\n              }\n            };\n\n            if (_properties) {\n              polygon.properties = feature.properties;\n            }\n\n            polygons.push(polygon);\n          }\n\n          if (geometry.type === 'LineString' || geometry.type === 'MultiLineString') {\n            coordinates = (PolylineLayer.isSingle(coordinates)) ? [coordinates] : coordinates;\n\n            var converted = coordinates.map(_coordinates => {\n              return _coordinates.map(coordinate => {\n                return LatLon(coordinate[1], coordinate[0]);\n              });\n            });\n\n            var point;\n            var projected = converted.map((_coordinates) => {\n              return _coordinates.map((latlon) => {\n                point = Geo.latLonToPoint(latlon)._subtract(originPoint);\n\n                if (!pointScale) {\n                  pointScale = Geo.pointScale(latlon);\n                }\n\n                return point;\n              });\n            });\n\n            var polyline = {\n              projected: projected,\n              options: {\n                pointScale: pointScale,\n                style: style\n              }\n            };\n\n            if (_properties) {\n              polyline.properties = feature.properties;\n            }\n\n            polylines.push(polyline);\n          }\n\n          if (geometry.type === 'Point' || geometry.type === 'MultiPoint') {\n            coordinates = (PointLayer.isSingle(coordinates)) ? [coordinates] : coordinates;\n\n            var converted = coordinates.map(coordinate => {\n              return LatLon(coordinate[1], coordinate[0]);\n            });\n\n            var point;\n            var projected = converted.map((latlon) => {\n              point = Geo.latLonToPoint(latlon)._subtract(originPoint);\n\n              if (!pointScale) {\n                pointScale = Geo.pointScale(latlon);\n              }\n\n              return point;\n            });\n\n            var point = {\n              projected: projected,\n              options: {\n                pointGeometry: pointGeometry(feature),\n                pointScale: pointScale,\n                style: style\n              }\n            };\n\n            if (_properties) {\n              point.properties = feature.properties;\n            }\n\n            points.push(point);\n          }\n        };\n\n        var polygonBufferPromises = [];\n        var polylineBufferPromises = [];\n        var pointBufferPromises = [];\n\n        var polygon;\n        for (var i = 0; i < polygons.length; i++) {\n          polygon = polygons[i];\n          polygonBufferPromises.push(PolygonLayer.SetBufferAttributes(polygon.projected, polygon.options));\n        };\n\n        var polyline;\n        for (var i = 0; i < polylines.length; i++) {\n          polyline = polylines[i];\n          polylineBufferPromises.push(PolylineLayer.SetBufferAttributes(polyline.projected, polyline.options));\n        };\n\n        var point;\n        for (var i = 0; i < points.length; i++) {\n          point = points[i];\n          pointBufferPromises.push(PointLayer.SetBufferAttributes(point.projected, point.options));\n        };\n\n        var data = {};\n        var transferrables = [];\n\n        // TODO: Make this work with polylines too\n        // TODO: Make this so it's not a nest of promises\n        GeoJSONWorkerLayer.ProcessPolygons(polygonBufferPromises, polygons, _properties).then((result) => {\n          data.polygons = result.data;\n          transferrables = transferrables.concat(result.transferrables);\n\n          GeoJSONWorkerLayer.ProcessPolylines(polylineBufferPromises, polylines, _properties).then((result) => {\n            data.polylines = result.data;\n            transferrables = transferrables.concat(result.transferrables);\n\n            GeoJSONWorkerLayer.ProcessPoints(pointBufferPromises, points, _properties).then((result) => {\n              data.points = result.data;\n              transferrables = transferrables.concat(result.transferrables);\n\n              resolve({\n                data: data,\n                transferrables: transferrables\n              });\n            });\n          });\n        });\n      });\n    });\n  }\n\n  static ProcessPolygons(polygonPromises, polygons, _properties) {\n    return new Promise((resolve, reject) => {\n      Promise.all(polygonPromises).then((results) => {\n        var transferrables = [];\n\n        var positions = [];\n        var normals = [];\n        var colors = [];\n        var tops = [];\n\n        var outlinePositions = [];\n        var outlineColors = [];\n\n        var properties = [];\n\n        var flats = [];\n        var polygon;\n\n        var result;\n        for (var i = 0; i < results.length; i++) {\n          result = results[i];\n\n          polygon = polygons[i];\n\n          // WORKERS: Making this a typed array will speed up transfer time\n          // As things stand this adds on a few milliseconds\n          flats.push(result.flat);\n\n          // WORKERS: result.attributes is actually an array of polygons for each\n          // feature, though the current logic isn't keeping these all together\n\n          var attributes;\n          for (var j = 0; j < result.attributes.length; j++) {\n            attributes = result.attributes[j];\n\n            positions.push(attributes.positions);\n            normals.push(attributes.normals);\n            colors.push(attributes.colors);\n            tops.push(attributes.tops);\n\n            if (_properties) {\n              properties.push(Buffer.stringToUint8Array(JSON.stringify(polygon.properties)));\n            }\n          };\n\n          var outlineAttributes;\n          for (var j = 0; j < result.outlineAttributes.length; j++) {\n            outlineAttributes = result.outlineAttributes[j];\n\n            outlinePositions.push(outlineAttributes.positions);\n            outlineColors.push(outlineAttributes.colors);\n          };\n        };\n\n        var mergedAttributes = {\n          positions: Buffer.mergeFloat32Arrays(positions),\n          normals: Buffer.mergeFloat32Arrays(normals),\n          colors: Buffer.mergeFloat32Arrays(colors),\n          tops: Buffer.mergeFloat32Arrays(tops)\n        };\n\n        var mergedOutlineAttributes = {\n          positions: Buffer.mergeFloat32Arrays(outlinePositions),\n          colors: Buffer.mergeFloat32Arrays(outlineColors)\n        };\n\n        transferrables.push(mergedAttributes.positions[0].buffer);\n        transferrables.push(mergedAttributes.positions[1].buffer);\n\n        transferrables.push(mergedAttributes.normals[0].buffer);\n        transferrables.push(mergedAttributes.normals[1].buffer);\n\n        transferrables.push(mergedAttributes.colors[0].buffer);\n        transferrables.push(mergedAttributes.colors[1].buffer);\n\n        transferrables.push(mergedAttributes.tops[0].buffer);\n        transferrables.push(mergedAttributes.tops[1].buffer);\n\n        transferrables.push(mergedOutlineAttributes.positions[0].buffer);\n        transferrables.push(mergedOutlineAttributes.positions[1].buffer);\n\n        transferrables.push(mergedOutlineAttributes.colors[0].buffer);\n        transferrables.push(mergedOutlineAttributes.colors[1].buffer);\n\n        var mergedProperties;\n        if (_properties) {\n          mergedProperties = Buffer.mergeUint8Arrays(properties);\n\n          transferrables.push(mergedProperties[0].buffer);\n          transferrables.push(mergedProperties[1].buffer);\n        }\n\n        var output = {\n          attributes: mergedAttributes,\n          outlineAttributes: mergedOutlineAttributes,\n          flats: flats\n        };\n\n        if (_properties) {\n          output.properties = mergedProperties;\n        }\n\n        // TODO: Also return GeoJSON features that can be mapped to objects on\n        // the main thread. Allow user to provide filter / toggles to only return\n        // properties from the GeoJSON that they need (eg. don't return geometry,\n        // or don't return properties.height)\n        resolve({\n          data: output,\n          transferrables: transferrables\n        });\n      }).catch(reject);\n    });\n  }\n\n  static ProcessPolylines(polylinePromises, polylines, _properties) {\n    return new Promise((resolve, reject) => {\n      Promise.all(polylinePromises).then((results) => {\n        var transferrables = [];\n\n        var positions = [];\n        var colors = [];\n\n        var properties = [];\n\n        var flats = [];\n        var polyline;\n\n        var result;\n        for (var i = 0; i < results.length; i++) {\n          result = results[i];\n\n          polyline = polylines[i];\n\n          // WORKERS: Making this a typed array will speed up transfer time\n          // As things stand this adds on a few milliseconds\n          flats.push(result.flat);\n\n          // WORKERS: result.attributes is actually an array of polygons for each\n          // feature, though the current logic isn't keeping these all together\n\n          var attributes;\n          for (var j = 0; j < result.attributes.length; j++) {\n            attributes = result.attributes[j];\n\n            positions.push(attributes.positions);\n            colors.push(attributes.colors);\n\n            if (_properties) {\n              properties.push(Buffer.stringToUint8Array(JSON.stringify(polyline.properties)));\n            }\n          };\n        };\n\n        var mergedAttributes = {\n          positions: Buffer.mergeFloat32Arrays(positions),\n          colors: Buffer.mergeFloat32Arrays(colors)\n        };\n\n        transferrables.push(mergedAttributes.positions[0].buffer);\n        transferrables.push(mergedAttributes.positions[1].buffer);\n\n        transferrables.push(mergedAttributes.colors[0].buffer);\n        transferrables.push(mergedAttributes.colors[1].buffer);\n\n        var mergedProperties;\n        if (_properties) {\n          mergedProperties = Buffer.mergeUint8Arrays(properties);\n\n          transferrables.push(mergedProperties[0].buffer);\n          transferrables.push(mergedProperties[1].buffer);\n        }\n\n        var output = {\n          attributes: mergedAttributes,\n          flats: flats\n        };\n\n        if (_properties) {\n          output.properties = mergedProperties;\n        }\n\n        // TODO: Also return GeoJSON features that can be mapped to objects on\n        // the main thread. Allow user to provide filter / toggles to only return\n        // properties from the GeoJSON that they need (eg. don't return geometry,\n        // or don't return properties.height)\n        resolve({\n          data: output,\n          transferrables: transferrables\n        });\n      }).catch(reject);\n    });\n  }\n\n  // TODO: Dedupe with ProcessPolygons as they are identical\n  static ProcessPoints(pointPromises, points, _properties) {\n    return new Promise((resolve, reject) => {\n      Promise.all(pointPromises).then((results) => {\n        var transferrables = [];\n\n        var positions = [];\n        var normals = [];\n        var colors = [];\n\n        var properties = [];\n\n        var flats = [];\n        var point;\n\n        var result;\n        for (var i = 0; i < results.length; i++) {\n          result = results[i];\n\n          point = points[i];\n\n          // WORKERS: Making this a typed array will speed up transfer time\n          // As things stand this adds on a few milliseconds\n          flats.push(result.flat);\n\n          // WORKERS: result.attributes is actually an array of polygons for each\n          // feature, though the current logic isn't keeping these all together\n\n          var attributes;\n          for (var j = 0; j < result.attributes.length; j++) {\n            attributes = result.attributes[j];\n\n            positions.push(attributes.positions);\n            normals.push(attributes.normals);\n            colors.push(attributes.colors);\n\n            if (_properties) {\n              properties.push(Buffer.stringToUint8Array(JSON.stringify(polygon.properties)));\n            }\n          };\n        };\n\n        var mergedAttributes = {\n          positions: Buffer.mergeFloat32Arrays(positions),\n          normals: Buffer.mergeFloat32Arrays(normals),\n          colors: Buffer.mergeFloat32Arrays(colors)\n        };\n\n        transferrables.push(mergedAttributes.positions[0].buffer);\n        transferrables.push(mergedAttributes.positions[1].buffer);\n\n        transferrables.push(mergedAttributes.normals[0].buffer);\n        transferrables.push(mergedAttributes.normals[1].buffer);\n\n        transferrables.push(mergedAttributes.colors[0].buffer);\n        transferrables.push(mergedAttributes.colors[1].buffer);\n\n        var mergedProperties;\n        if (_properties) {\n          mergedProperties = Buffer.mergeUint8Arrays(properties);\n\n          transferrables.push(mergedProperties[0].buffer);\n          transferrables.push(mergedProperties[1].buffer);\n        }\n\n        var output = {\n          attributes: mergedAttributes,\n          flats: flats\n        };\n\n        if (_properties) {\n          output.properties = mergedProperties;\n        }\n\n        // TODO: Also return GeoJSON features that can be mapped to objects on\n        // the main thread. Allow user to provide filter / toggles to only return\n        // properties from the GeoJSON that they need (eg. don't return geometry,\n        // or don't return properties.height)\n        resolve({\n          data: output,\n          transferrables: transferrables\n        });\n      }).catch(reject);\n    });\n  }\n\n  static ProcessGeoJSON(geojson, headers) {\n    if (typeof geojson === 'string') {\n      return GeoJSONWorkerLayer.RequestGeoJSON(geojson, headers);\n    } else {\n      return Promise.resolve(JSON.parse(Buffer.uint8ArrayToString(geojson)));\n    }\n  }\n\n  static RequestGeoJSON(path, headers) {\n    return reqwest({\n      url: path,\n      type: 'json',\n      crossOrigin: true,\n      headers: headers\n    });\n  }\n\n  // Create and store mesh from buffer attributes\n  //\n  // Could make this an abstract method for each geometry layer\n  _setPolygonMesh(attributes, attributeLengths, style, flat) {\n    if (!this._world) {\n      return Promise.reject();\n    }\n\n    return PolygonLayer.SetMesh(attributes, attributeLengths, flat, style, this._options, this._world._environment._skybox);\n  }\n\n  _setPolylineMesh(attributes, attributeLengths, style, flat) {\n    if (!this._world) {\n      return Promise.reject();\n    }\n\n    return PolylineLayer.SetMesh(attributes, attributeLengths, flat, style, this._options);\n  }\n\n  _setPointMesh(attributes, attributeLengths, style, flat) {\n    if (!this._world) {\n      return Promise.reject();\n    }\n\n    return PointLayer.SetMesh(attributes, attributeLengths, flat, style, this._options, this._world._environment._skybox);\n  }\n\n  // Set up and re-emit interaction events\n  _addPicking(pickingId, properties) {\n    this._world.on('pick-click-' + pickingId, (pickingId, point2d, point3d, intersects) => {\n      this._world.emit('click', this, properties, point2d, point3d);\n    });\n\n    this._world.on('pick-hover-' + pickingId, (pickingId, point2d, point3d, intersects) => {\n      this._world.emit('hover', this, properties, point2d, point3d);\n    });\n  }\n\n  // TODO: Finish cleanup\n  destroy() {\n    // Run common destruction logic from parent\n    super.destroy();\n  }\n}\n\nexport default GeoJSONWorkerLayer;\n\nvar noNew = function(geojson, options) {\n  return new GeoJSONWorkerLayer(geojson, options);\n};\n\nexport {noNew as geoJSONWorkerLayer};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/GeoJSONWorkerLayer.js\n **/","/*!\n  * Reqwest! A general purpose XHR connection manager\n  * license MIT (c) Dustin Diaz 2015\n  * https://github.com/ded/reqwest\n  */\n\n!function (name, context, definition) {\n  if (typeof module != 'undefined' && module.exports) module.exports = definition()\n  else if (typeof define == 'function' && define.amd) define(definition)\n  else context[name] = definition()\n}('reqwest', this, function () {\n\n  var context = this\n\n  if ('window' in context) {\n    var doc = document\n      , byTag = 'getElementsByTagName'\n      , head = doc[byTag]('head')[0]\n  } else {\n    var XHR2\n    try {\n      XHR2 = require('xhr2')\n    } catch (ex) {\n      throw new Error('Peer dependency `xhr2` required! Please npm install xhr2')\n    }\n  }\n\n\n  var httpsRe = /^http/\n    , protocolRe = /(^\\w+):\\/\\//\n    , twoHundo = /^(20\\d|1223)$/ //http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request\n    , readyState = 'readyState'\n    , contentType = 'Content-Type'\n    , requestedWith = 'X-Requested-With'\n    , uniqid = 0\n    , callbackPrefix = 'reqwest_' + (+new Date())\n    , lastValue // data stored by the most recent JSONP callback\n    , xmlHttpRequest = 'XMLHttpRequest'\n    , xDomainRequest = 'XDomainRequest'\n    , noop = function () {}\n\n    , isArray = typeof Array.isArray == 'function'\n        ? Array.isArray\n        : function (a) {\n            return a instanceof Array\n          }\n\n    , defaultHeaders = {\n          'contentType': 'application/x-www-form-urlencoded'\n        , 'requestedWith': xmlHttpRequest\n        , 'accept': {\n              '*':  'text/javascript, text/html, application/xml, text/xml, */*'\n            , 'xml':  'application/xml, text/xml'\n            , 'html': 'text/html'\n            , 'text': 'text/plain'\n            , 'json': 'application/json, text/javascript'\n            , 'js':   'application/javascript, text/javascript'\n          }\n      }\n\n    , xhr = function(o) {\n        // is it x-domain\n        if (o['crossOrigin'] === true) {\n          var xhr = context[xmlHttpRequest] ? new XMLHttpRequest() : null\n          if (xhr && 'withCredentials' in xhr) {\n            return xhr\n          } else if (context[xDomainRequest]) {\n            return new XDomainRequest()\n          } else {\n            throw new Error('Browser does not support cross-origin requests')\n          }\n        } else if (context[xmlHttpRequest]) {\n          return new XMLHttpRequest()\n        } else if (XHR2) {\n          return new XHR2()\n        } else {\n          return new ActiveXObject('Microsoft.XMLHTTP')\n        }\n      }\n    , globalSetupOptions = {\n        dataFilter: function (data) {\n          return data\n        }\n      }\n\n  function succeed(r) {\n    var protocol = protocolRe.exec(r.url)\n    protocol = (protocol && protocol[1]) || context.location.protocol\n    return httpsRe.test(protocol) ? twoHundo.test(r.request.status) : !!r.request.response\n  }\n\n  function handleReadyState(r, success, error) {\n    return function () {\n      // use _aborted to mitigate against IE err c00c023f\n      // (can't read props on aborted request objects)\n      if (r._aborted) return error(r.request)\n      if (r._timedOut) return error(r.request, 'Request is aborted: timeout')\n      if (r.request && r.request[readyState] == 4) {\n        r.request.onreadystatechange = noop\n        if (succeed(r)) success(r.request)\n        else\n          error(r.request)\n      }\n    }\n  }\n\n  function setHeaders(http, o) {\n    var headers = o['headers'] || {}\n      , h\n\n    headers['Accept'] = headers['Accept']\n      || defaultHeaders['accept'][o['type']]\n      || defaultHeaders['accept']['*']\n\n    var isAFormData = typeof FormData !== 'undefined' && (o['data'] instanceof FormData);\n    // breaks cross-origin requests with legacy browsers\n    if (!o['crossOrigin'] && !headers[requestedWith]) headers[requestedWith] = defaultHeaders['requestedWith']\n    if (!headers[contentType] && !isAFormData) headers[contentType] = o['contentType'] || defaultHeaders['contentType']\n    for (h in headers)\n      headers.hasOwnProperty(h) && 'setRequestHeader' in http && http.setRequestHeader(h, headers[h])\n  }\n\n  function setCredentials(http, o) {\n    if (typeof o['withCredentials'] !== 'undefined' && typeof http.withCredentials !== 'undefined') {\n      http.withCredentials = !!o['withCredentials']\n    }\n  }\n\n  function generalCallback(data) {\n    lastValue = data\n  }\n\n  function urlappend (url, s) {\n    return url + (/\\?/.test(url) ? '&' : '?') + s\n  }\n\n  function handleJsonp(o, fn, err, url) {\n    var reqId = uniqid++\n      , cbkey = o['jsonpCallback'] || 'callback' // the 'callback' key\n      , cbval = o['jsonpCallbackName'] || reqwest.getcallbackPrefix(reqId)\n      , cbreg = new RegExp('((^|\\\\?|&)' + cbkey + ')=([^&]+)')\n      , match = url.match(cbreg)\n      , script = doc.createElement('script')\n      , loaded = 0\n      , isIE10 = navigator.userAgent.indexOf('MSIE 10.0') !== -1\n\n    if (match) {\n      if (match[3] === '?') {\n        url = url.replace(cbreg, '$1=' + cbval) // wildcard callback func name\n      } else {\n        cbval = match[3] // provided callback func name\n      }\n    } else {\n      url = urlappend(url, cbkey + '=' + cbval) // no callback details, add 'em\n    }\n\n    context[cbval] = generalCallback\n\n    script.type = 'text/javascript'\n    script.src = url\n    script.async = true\n    if (typeof script.onreadystatechange !== 'undefined' && !isIE10) {\n      // need this for IE due to out-of-order onreadystatechange(), binding script\n      // execution to an event listener gives us control over when the script\n      // is executed. See http://jaubourg.net/2010/07/loading-script-as-onclick-handler-of.html\n      script.htmlFor = script.id = '_reqwest_' + reqId\n    }\n\n    script.onload = script.onreadystatechange = function () {\n      if ((script[readyState] && script[readyState] !== 'complete' && script[readyState] !== 'loaded') || loaded) {\n        return false\n      }\n      script.onload = script.onreadystatechange = null\n      script.onclick && script.onclick()\n      // Call the user callback with the last value stored and clean up values and scripts.\n      fn(lastValue)\n      lastValue = undefined\n      head.removeChild(script)\n      loaded = 1\n    }\n\n    // Add the script to the DOM head\n    head.appendChild(script)\n\n    // Enable JSONP timeout\n    return {\n      abort: function () {\n        script.onload = script.onreadystatechange = null\n        err({}, 'Request is aborted: timeout', {})\n        lastValue = undefined\n        head.removeChild(script)\n        loaded = 1\n      }\n    }\n  }\n\n  function getRequest(fn, err) {\n    var o = this.o\n      , method = (o['method'] || 'GET').toUpperCase()\n      , url = typeof o === 'string' ? o : o['url']\n      // convert non-string objects to query-string form unless o['processData'] is false\n      , data = (o['processData'] !== false && o['data'] && typeof o['data'] !== 'string')\n        ? reqwest.toQueryString(o['data'])\n        : (o['data'] || null)\n      , http\n      , sendWait = false\n\n    // if we're working on a GET request and we have data then we should append\n    // query string to end of URL and not post data\n    if ((o['type'] == 'jsonp' || method == 'GET') && data) {\n      url = urlappend(url, data)\n      data = null\n    }\n\n    if (o['type'] == 'jsonp') return handleJsonp(o, fn, err, url)\n\n    // get the xhr from the factory if passed\n    // if the factory returns null, fall-back to ours\n    http = (o.xhr && o.xhr(o)) || xhr(o)\n\n    http.open(method, url, o['async'] === false ? false : true)\n    setHeaders(http, o)\n    setCredentials(http, o)\n    if (context[xDomainRequest] && http instanceof context[xDomainRequest]) {\n        http.onload = fn\n        http.onerror = err\n        // NOTE: see\n        // http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/30ef3add-767c-4436-b8a9-f1ca19b4812e\n        http.onprogress = function() {}\n        sendWait = true\n    } else {\n      http.onreadystatechange = handleReadyState(this, fn, err)\n    }\n    o['before'] && o['before'](http)\n    if (sendWait) {\n      setTimeout(function () {\n        http.send(data)\n      }, 200)\n    } else {\n      http.send(data)\n    }\n    return http\n  }\n\n  function Reqwest(o, fn) {\n    this.o = o\n    this.fn = fn\n\n    init.apply(this, arguments)\n  }\n\n  function setType(header) {\n    // json, javascript, text/plain, text/html, xml\n    if (header === null) return undefined; //In case of no content-type.\n    if (header.match('json')) return 'json'\n    if (header.match('javascript')) return 'js'\n    if (header.match('text')) return 'html'\n    if (header.match('xml')) return 'xml'\n  }\n\n  function init(o, fn) {\n\n    this.url = typeof o == 'string' ? o : o['url']\n    this.timeout = null\n\n    // whether request has been fulfilled for purpose\n    // of tracking the Promises\n    this._fulfilled = false\n    // success handlers\n    this._successHandler = function(){}\n    this._fulfillmentHandlers = []\n    // error handlers\n    this._errorHandlers = []\n    // complete (both success and fail) handlers\n    this._completeHandlers = []\n    this._erred = false\n    this._responseArgs = {}\n\n    var self = this\n\n    fn = fn || function () {}\n\n    if (o['timeout']) {\n      this.timeout = setTimeout(function () {\n        timedOut()\n      }, o['timeout'])\n    }\n\n    if (o['success']) {\n      this._successHandler = function () {\n        o['success'].apply(o, arguments)\n      }\n    }\n\n    if (o['error']) {\n      this._errorHandlers.push(function () {\n        o['error'].apply(o, arguments)\n      })\n    }\n\n    if (o['complete']) {\n      this._completeHandlers.push(function () {\n        o['complete'].apply(o, arguments)\n      })\n    }\n\n    function complete (resp) {\n      o['timeout'] && clearTimeout(self.timeout)\n      self.timeout = null\n      while (self._completeHandlers.length > 0) {\n        self._completeHandlers.shift()(resp)\n      }\n    }\n\n    function success (resp) {\n      var type = o['type'] || resp && setType(resp.getResponseHeader('Content-Type')) // resp can be undefined in IE\n      resp = (type !== 'jsonp') ? self.request : resp\n      // use global data filter on response text\n      var filteredResponse = globalSetupOptions.dataFilter(resp.responseText, type)\n        , r = filteredResponse\n      try {\n        resp.responseText = r\n      } catch (e) {\n        // can't assign this in IE<=8, just ignore\n      }\n      if (r) {\n        switch (type) {\n        case 'json':\n          try {\n            resp = context.JSON ? context.JSON.parse(r) : eval('(' + r + ')')\n          } catch (err) {\n            return error(resp, 'Could not parse JSON in response', err)\n          }\n          break\n        case 'js':\n          resp = eval(r)\n          break\n        case 'html':\n          resp = r\n          break\n        case 'xml':\n          resp = resp.responseXML\n              && resp.responseXML.parseError // IE trololo\n              && resp.responseXML.parseError.errorCode\n              && resp.responseXML.parseError.reason\n            ? null\n            : resp.responseXML\n          break\n        }\n      }\n\n      self._responseArgs.resp = resp\n      self._fulfilled = true\n      fn(resp)\n      self._successHandler(resp)\n      while (self._fulfillmentHandlers.length > 0) {\n        resp = self._fulfillmentHandlers.shift()(resp)\n      }\n\n      complete(resp)\n    }\n\n    function timedOut() {\n      self._timedOut = true\n      self.request.abort()\n    }\n\n    function error(resp, msg, t) {\n      resp = self.request\n      self._responseArgs.resp = resp\n      self._responseArgs.msg = msg\n      self._responseArgs.t = t\n      self._erred = true\n      while (self._errorHandlers.length > 0) {\n        self._errorHandlers.shift()(resp, msg, t)\n      }\n      complete(resp)\n    }\n\n    this.request = getRequest.call(this, success, error)\n  }\n\n  Reqwest.prototype = {\n    abort: function () {\n      this._aborted = true\n      this.request.abort()\n    }\n\n  , retry: function () {\n      init.call(this, this.o, this.fn)\n    }\n\n    /**\n     * Small deviation from the Promises A CommonJs specification\n     * http://wiki.commonjs.org/wiki/Promises/A\n     */\n\n    /**\n     * `then` will execute upon successful requests\n     */\n  , then: function (success, fail) {\n      success = success || function () {}\n      fail = fail || function () {}\n      if (this._fulfilled) {\n        this._responseArgs.resp = success(this._responseArgs.resp)\n      } else if (this._erred) {\n        fail(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t)\n      } else {\n        this._fulfillmentHandlers.push(success)\n        this._errorHandlers.push(fail)\n      }\n      return this\n    }\n\n    /**\n     * `always` will execute whether the request succeeds or fails\n     */\n  , always: function (fn) {\n      if (this._fulfilled || this._erred) {\n        fn(this._responseArgs.resp)\n      } else {\n        this._completeHandlers.push(fn)\n      }\n      return this\n    }\n\n    /**\n     * `fail` will execute when the request fails\n     */\n  , fail: function (fn) {\n      if (this._erred) {\n        fn(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t)\n      } else {\n        this._errorHandlers.push(fn)\n      }\n      return this\n    }\n  , 'catch': function (fn) {\n      return this.fail(fn)\n    }\n  }\n\n  function reqwest(o, fn) {\n    return new Reqwest(o, fn)\n  }\n\n  // normalize newline variants according to spec -> CRLF\n  function normalize(s) {\n    return s ? s.replace(/\\r?\\n/g, '\\r\\n') : ''\n  }\n\n  function serial(el, cb) {\n    var n = el.name\n      , t = el.tagName.toLowerCase()\n      , optCb = function (o) {\n          // IE gives value=\"\" even where there is no value attribute\n          // 'specified' ref: http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-862529273\n          if (o && !o['disabled'])\n            cb(n, normalize(o['attributes']['value'] && o['attributes']['value']['specified'] ? o['value'] : o['text']))\n        }\n      , ch, ra, val, i\n\n    // don't serialize elements that are disabled or without a name\n    if (el.disabled || !n) return\n\n    switch (t) {\n    case 'input':\n      if (!/reset|button|image|file/i.test(el.type)) {\n        ch = /checkbox/i.test(el.type)\n        ra = /radio/i.test(el.type)\n        val = el.value\n        // WebKit gives us \"\" instead of \"on\" if a checkbox has no value, so correct it here\n        ;(!(ch || ra) || el.checked) && cb(n, normalize(ch && val === '' ? 'on' : val))\n      }\n      break\n    case 'textarea':\n      cb(n, normalize(el.value))\n      break\n    case 'select':\n      if (el.type.toLowerCase() === 'select-one') {\n        optCb(el.selectedIndex >= 0 ? el.options[el.selectedIndex] : null)\n      } else {\n        for (i = 0; el.length && i < el.length; i++) {\n          el.options[i].selected && optCb(el.options[i])\n        }\n      }\n      break\n    }\n  }\n\n  // collect up all form elements found from the passed argument elements all\n  // the way down to child elements; pass a '<form>' or form fields.\n  // called with 'this'=callback to use for serial() on each element\n  function eachFormElement() {\n    var cb = this\n      , e, i\n      , serializeSubtags = function (e, tags) {\n          var i, j, fa\n          for (i = 0; i < tags.length; i++) {\n            fa = e[byTag](tags[i])\n            for (j = 0; j < fa.length; j++) serial(fa[j], cb)\n          }\n        }\n\n    for (i = 0; i < arguments.length; i++) {\n      e = arguments[i]\n      if (/input|select|textarea/i.test(e.tagName)) serial(e, cb)\n      serializeSubtags(e, [ 'input', 'select', 'textarea' ])\n    }\n  }\n\n  // standard query string style serialization\n  function serializeQueryString() {\n    return reqwest.toQueryString(reqwest.serializeArray.apply(null, arguments))\n  }\n\n  // { 'name': 'value', ... } style serialization\n  function serializeHash() {\n    var hash = {}\n    eachFormElement.apply(function (name, value) {\n      if (name in hash) {\n        hash[name] && !isArray(hash[name]) && (hash[name] = [hash[name]])\n        hash[name].push(value)\n      } else hash[name] = value\n    }, arguments)\n    return hash\n  }\n\n  // [ { name: 'name', value: 'value' }, ... ] style serialization\n  reqwest.serializeArray = function () {\n    var arr = []\n    eachFormElement.apply(function (name, value) {\n      arr.push({name: name, value: value})\n    }, arguments)\n    return arr\n  }\n\n  reqwest.serialize = function () {\n    if (arguments.length === 0) return ''\n    var opt, fn\n      , args = Array.prototype.slice.call(arguments, 0)\n\n    opt = args.pop()\n    opt && opt.nodeType && args.push(opt) && (opt = null)\n    opt && (opt = opt.type)\n\n    if (opt == 'map') fn = serializeHash\n    else if (opt == 'array') fn = reqwest.serializeArray\n    else fn = serializeQueryString\n\n    return fn.apply(null, args)\n  }\n\n  reqwest.toQueryString = function (o, trad) {\n    var prefix, i\n      , traditional = trad || false\n      , s = []\n      , enc = encodeURIComponent\n      , add = function (key, value) {\n          // If value is a function, invoke it and return its value\n          value = ('function' === typeof value) ? value() : (value == null ? '' : value)\n          s[s.length] = enc(key) + '=' + enc(value)\n        }\n    // If an array was passed in, assume that it is an array of form elements.\n    if (isArray(o)) {\n      for (i = 0; o && i < o.length; i++) add(o[i]['name'], o[i]['value'])\n    } else {\n      // If traditional, encode the \"old\" way (the way 1.3.2 or older\n      // did it), otherwise encode params recursively.\n      for (prefix in o) {\n        if (o.hasOwnProperty(prefix)) buildParams(prefix, o[prefix], traditional, add)\n      }\n    }\n\n    // spaces should be + according to spec\n    return s.join('&').replace(/%20/g, '+')\n  }\n\n  function buildParams(prefix, obj, traditional, add) {\n    var name, i, v\n      , rbracket = /\\[\\]$/\n\n    if (isArray(obj)) {\n      // Serialize array item.\n      for (i = 0; obj && i < obj.length; i++) {\n        v = obj[i]\n        if (traditional || rbracket.test(prefix)) {\n          // Treat each array item as a scalar.\n          add(prefix, v)\n        } else {\n          buildParams(prefix + '[' + (typeof v === 'object' ? i : '') + ']', v, traditional, add)\n        }\n      }\n    } else if (obj && obj.toString() === '[object Object]') {\n      // Serialize object item.\n      for (name in obj) {\n        buildParams(prefix + '[' + name + ']', obj[name], traditional, add)\n      }\n\n    } else {\n      // Serialize scalar item.\n      add(prefix, obj)\n    }\n  }\n\n  reqwest.getcallbackPrefix = function () {\n    return callbackPrefix\n  }\n\n  // jQuery and Zepto compatibility, differences can be remapped here so you can call\n  // .ajax.compat(options, callback)\n  reqwest.compat = function (o, fn) {\n    if (o) {\n      o['type'] && (o['method'] = o['type']) && delete o['type']\n      o['dataType'] && (o['type'] = o['dataType'])\n      o['jsonpCallback'] && (o['jsonpCallbackName'] = o['jsonpCallback']) && delete o['jsonpCallback']\n      o['jsonp'] && (o['jsonpCallback'] = o['jsonp'])\n    }\n    return new Reqwest(o, fn)\n  }\n\n  reqwest.ajaxSetup = function (options) {\n    options = options || {}\n    for (var k in options) {\n      globalSetupOptions[k] = options[k]\n    }\n  }\n\n  return reqwest\n});\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/reqwest/reqwest.js\n ** module id = 23\n ** module chunks = 0\n **/","/*\n * GeoJSON helpers for handling data and generating objects\n */\n\nimport THREE from 'three';\nimport * as topojson from 'topojson';\nimport geojsonMerge from 'geojson-merge';\nimport earcut from 'earcut';\nimport extrudePolygon from './extrudePolygon';\n\n// TODO: Make it so height can be per-coordinate / point but connected together\n// as a linestring (eg. GPS points with an elevation at each point)\n//\n// This isn't really valid GeoJSON so perhaps something best left to an external\n// component for now, until a better approach can be considered\n//\n// See: http://lists.geojson.org/pipermail/geojson-geojson.org/2009-June/000489.html\n\n// Light and dark colours used for poor-mans AO gradient on object sides\nvar light = new THREE.Color(0xffffff);\nvar shadow  = new THREE.Color(0x666666);\n\nvar GeoJSON = (function() {\n  var defaultStyle = {\n    color: '#ffffff',\n    outline: false,\n    outlineColor: '#000000',\n    transparent: false,\n    opacity: 1,\n    blending: THREE.NormalBlending,\n    height: 0,\n    lineOpacity: 1,\n    lineTransparent: false,\n    lineColor: '#ffffff',\n    lineWidth: 1,\n    lineBlending: THREE.NormalBlending\n  };\n\n  // Attempts to merge together multiple GeoJSON Features or FeatureCollections\n  // into a single FeatureCollection\n  var collectFeatures = function(data, _topojson) {\n    var collections = [];\n\n    if (_topojson) {\n      // TODO: Allow TopoJSON objects to be overridden as an option\n\n      // If not overridden, merge all features from all objects\n      for (var tk in data.objects) {\n        collections.push(topojson.feature(data, data.objects[tk]));\n      }\n\n      return geojsonMerge(collections);\n    } else {\n      // If root doesn't have a type then let's see if there are features in the\n      // next step down\n      if (!data.type) {\n        // TODO: Allow GeoJSON objects to be overridden as an option\n\n        // If not overridden, merge all features from all objects\n        for (var gk in data) {\n          if (!data[gk].type) {\n            continue;\n          }\n\n          collections.push(data[gk]);\n        }\n\n        return geojsonMerge(collections);\n      } else if (Array.isArray(data)) {\n        return geojsonMerge(data);\n      } else {\n        return data;\n      }\n    }\n  };\n\n  // TODO: This is only used by GeoJSONTile so either roll it into that or\n  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n  var lineStringAttributes = function(coordinates, colour, height) {\n    var _coords = [];\n    var _colours = [];\n\n    var nextCoord;\n\n    // Connect coordinate with the next to make a pair\n    //\n    // LineSegments requires pairs of vertices so repeat the last point if\n    // there's an odd number of vertices\n    coordinates.forEach((coordinate, index) => {\n      _colours.push([colour.r, colour.g, colour.b]);\n      _coords.push([coordinate[0], height, coordinate[1]]);\n\n      nextCoord = (coordinates[index + 1]) ? coordinates[index + 1] : coordinate;\n\n      _colours.push([colour.r, colour.g, colour.b]);\n      _coords.push([nextCoord[0], height, nextCoord[1]]);\n    });\n\n    return {\n      vertices: _coords,\n      colours: _colours\n    };\n  };\n\n  // TODO: This is only used by GeoJSONTile so either roll it into that or\n  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n  var multiLineStringAttributes = function(coordinates, colour, height) {\n    var _coords = [];\n    var _colours = [];\n\n    var result;\n    coordinates.forEach(coordinate => {\n      result = lineStringAttributes(coordinate, colour, height);\n\n      result.vertices.forEach(coord => {\n        _coords.push(coord);\n      });\n\n      result.colours.forEach(colour => {\n        _colours.push(colour);\n      });\n    });\n\n    return {\n      vertices: _coords,\n      colours: _colours\n    };\n  };\n\n  // TODO: This is only used by GeoJSONTile so either roll it into that or\n  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n  var polygonAttributes = function(coordinates, colour, height) {\n    var earcutData = _toEarcut(coordinates);\n\n    var faces = _triangulate(earcutData.vertices, earcutData.holes, earcutData.dimensions);\n\n    var groupedVertices = [];\n    for (i = 0, il = earcutData.vertices.length; i < il; i += earcutData.dimensions) {\n      groupedVertices.push(earcutData.vertices.slice(i, i + earcutData.dimensions));\n    }\n\n    var extruded = extrudePolygon(groupedVertices, faces, {\n      bottom: 0,\n      top: height\n    });\n\n    var topColor = colour.clone().multiply(light);\n    var bottomColor = colour.clone().multiply(shadow);\n\n    var _vertices = extruded.positions;\n    var _faces = [];\n    var _colours = [];\n\n    var _colour;\n    extruded.top.forEach((face, fi) => {\n      _colour = [];\n\n      _colour.push([colour.r, colour.g, colour.b]);\n      _colour.push([colour.r, colour.g, colour.b]);\n      _colour.push([colour.r, colour.g, colour.b]);\n\n      _faces.push(face);\n      _colours.push(_colour);\n    });\n\n    var allFlat = true;\n\n    if (extruded.sides) {\n      if (allFlat) {\n        allFlat = false;\n      }\n\n      // Set up colours for every vertex with poor-mans AO on the sides\n      extruded.sides.forEach((face, fi) => {\n        _colour = [];\n\n        // First face is always bottom-bottom-top\n        if (fi % 2 === 0) {\n          _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n          _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n          _colour.push([topColor.r, topColor.g, topColor.b]);\n        // Reverse winding for the second face\n        // top-top-bottom\n        } else {\n          _colour.push([topColor.r, topColor.g, topColor.b]);\n          _colour.push([topColor.r, topColor.g, topColor.b]);\n          _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n        }\n\n        _faces.push(face);\n        _colours.push(_colour);\n      });\n    }\n\n    // Skip bottom as there's no point rendering it\n    // allFaces.push(extruded.faces);\n\n    return {\n      vertices: _vertices,\n      faces: _faces,\n      colours: _colours,\n      flat: allFlat\n    };\n  };\n\n  // TODO: This is only used by GeoJSONTile so either roll it into that or\n  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n  var _toEarcut = function(data) {\n    var dim = data[0][0].length;\n    var result = {vertices: [], holes: [], dimensions: dim};\n    var holeIndex = 0;\n\n    for (var i = 0; i < data.length; i++) {\n      for (var j = 0; j < data[i].length; j++) {\n        for (var d = 0; d < dim; d++) {\n          result.vertices.push(data[i][j][d]);\n        }\n      }\n      if (i > 0) {\n        holeIndex += data[i - 1].length;\n        result.holes.push(holeIndex);\n      }\n    }\n\n    return result;\n  };\n\n  // TODO: This is only used by GeoJSONTile so either roll it into that or\n  // update GeoJSONTile to use the new GeoJSONLayer or geometry layers\n  var _triangulate = function(contour, holes, dim) {\n    // console.time('earcut');\n\n    var faces = earcut(contour, holes, dim);\n    var result = [];\n\n    for (i = 0, il = faces.length; i < il; i += 3) {\n      result.push(faces.slice(i, i + 3));\n    }\n\n    // console.timeEnd('earcut');\n\n    return result;\n  };\n\n  return {\n    defaultStyle: defaultStyle,\n    collectFeatures: collectFeatures,\n    lineStringAttributes: lineStringAttributes,\n    multiLineStringAttributes: multiLineStringAttributes,\n    polygonAttributes: polygonAttributes\n  };\n})();\n\nexport default GeoJSON;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/GeoJSON.js\n **/","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (factory((global.topojson = global.topojson || {})));\n}(this, (function (exports) { 'use strict';\n\nfunction noop() {}\n\nfunction transformAbsolute(transform) {\n  if (!transform) return noop;\n  var x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(point, i) {\n    if (!i) x0 = y0 = 0;\n    point[0] = (x0 += point[0]) * kx + dx;\n    point[1] = (y0 += point[1]) * ky + dy;\n  };\n}\n\nfunction transformRelative(transform) {\n  if (!transform) return noop;\n  var x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(point, i) {\n    if (!i) x0 = y0 = 0;\n    var x1 = Math.round((point[0] - dx) / kx),\n        y1 = Math.round((point[1] - dy) / ky);\n    point[0] = x1 - x0;\n    point[1] = y1 - y0;\n    x0 = x1;\n    y0 = y1;\n  };\n}\n\nfunction reverse(array, n) {\n  var t, j = array.length, i = j - n;\n  while (i < --j) t = array[i], array[i++] = array[j], array[j] = t;\n}\n\nfunction bisect(a, x) {\n  var lo = 0, hi = a.length;\n  while (lo < hi) {\n    var mid = lo + hi >>> 1;\n    if (a[mid] < x) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\nfunction feature(topology, o) {\n  return o.type === \"GeometryCollection\" ? {\n    type: \"FeatureCollection\",\n    features: o.geometries.map(function(o) { return feature$1(topology, o); })\n  } : feature$1(topology, o);\n}\n\nfunction feature$1(topology, o) {\n  var f = {\n    type: \"Feature\",\n    id: o.id,\n    properties: o.properties || {},\n    geometry: object(topology, o)\n  };\n  if (o.id == null) delete f.id;\n  return f;\n}\n\nfunction object(topology, o) {\n  var absolute = transformAbsolute(topology.transform),\n      arcs = topology.arcs;\n\n  function arc(i, points) {\n    if (points.length) points.pop();\n    for (var a = arcs[i < 0 ? ~i : i], k = 0, n = a.length, p; k < n; ++k) {\n      points.push(p = a[k].slice());\n      absolute(p, k);\n    }\n    if (i < 0) reverse(points, n);\n  }\n\n  function point(p) {\n    p = p.slice();\n    absolute(p, 0);\n    return p;\n  }\n\n  function line(arcs) {\n    var points = [];\n    for (var i = 0, n = arcs.length; i < n; ++i) arc(arcs[i], points);\n    if (points.length < 2) points.push(points[0].slice());\n    return points;\n  }\n\n  function ring(arcs) {\n    var points = line(arcs);\n    while (points.length < 4) points.push(points[0].slice());\n    return points;\n  }\n\n  function polygon(arcs) {\n    return arcs.map(ring);\n  }\n\n  function geometry(o) {\n    var t = o.type;\n    return t === \"GeometryCollection\" ? {type: t, geometries: o.geometries.map(geometry)}\n        : t in geometryType ? {type: t, coordinates: geometryType[t](o)}\n        : null;\n  }\n\n  var geometryType = {\n    Point: function(o) { return point(o.coordinates); },\n    MultiPoint: function(o) { return o.coordinates.map(point); },\n    LineString: function(o) { return line(o.arcs); },\n    MultiLineString: function(o) { return o.arcs.map(line); },\n    Polygon: function(o) { return polygon(o.arcs); },\n    MultiPolygon: function(o) { return o.arcs.map(polygon); }\n  };\n\n  return geometry(o);\n}\n\nfunction stitchArcs(topology, arcs) {\n  var stitchedArcs = {},\n      fragmentByStart = {},\n      fragmentByEnd = {},\n      fragments = [],\n      emptyIndex = -1;\n\n  // Stitch empty arcs first, since they may be subsumed by other arcs.\n  arcs.forEach(function(i, j) {\n    var arc = topology.arcs[i < 0 ? ~i : i], t;\n    if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {\n      t = arcs[++emptyIndex], arcs[emptyIndex] = i, arcs[j] = t;\n    }\n  });\n\n  arcs.forEach(function(i) {\n    var e = ends(i),\n        start = e[0],\n        end = e[1],\n        f, g;\n\n    if (f = fragmentByEnd[start]) {\n      delete fragmentByEnd[f.end];\n      f.push(i);\n      f.end = end;\n      if (g = fragmentByStart[end]) {\n        delete fragmentByStart[g.start];\n        var fg = g === f ? f : f.concat(g);\n        fragmentByStart[fg.start = f.start] = fragmentByEnd[fg.end = g.end] = fg;\n      } else {\n        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n      }\n    } else if (f = fragmentByStart[end]) {\n      delete fragmentByStart[f.start];\n      f.unshift(i);\n      f.start = start;\n      if (g = fragmentByEnd[start]) {\n        delete fragmentByEnd[g.end];\n        var gf = g === f ? f : g.concat(f);\n        fragmentByStart[gf.start = g.start] = fragmentByEnd[gf.end = f.end] = gf;\n      } else {\n        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n      }\n    } else {\n      f = [i];\n      fragmentByStart[f.start = start] = fragmentByEnd[f.end = end] = f;\n    }\n  });\n\n  function ends(i) {\n    var arc = topology.arcs[i < 0 ? ~i : i], p0 = arc[0], p1;\n    if (topology.transform) p1 = [0, 0], arc.forEach(function(dp) { p1[0] += dp[0], p1[1] += dp[1]; });\n    else p1 = arc[arc.length - 1];\n    return i < 0 ? [p1, p0] : [p0, p1];\n  }\n\n  function flush(fragmentByEnd, fragmentByStart) {\n    for (var k in fragmentByEnd) {\n      var f = fragmentByEnd[k];\n      delete fragmentByStart[f.start];\n      delete f.start;\n      delete f.end;\n      f.forEach(function(i) { stitchedArcs[i < 0 ? ~i : i] = 1; });\n      fragments.push(f);\n    }\n  }\n\n  flush(fragmentByEnd, fragmentByStart);\n  flush(fragmentByStart, fragmentByEnd);\n  arcs.forEach(function(i) { if (!stitchedArcs[i < 0 ? ~i : i]) fragments.push([i]); });\n\n  return fragments;\n}\n\nfunction mesh(topology) {\n  return object(topology, meshArcs.apply(this, arguments));\n}\n\nfunction meshArcs(topology, o, filter) {\n  var arcs = [];\n\n  function arc(i) {\n    var j = i < 0 ? ~i : i;\n    (geomsByArc[j] || (geomsByArc[j] = [])).push({i: i, g: geom});\n  }\n\n  function line(arcs) {\n    arcs.forEach(arc);\n  }\n\n  function polygon(arcs) {\n    arcs.forEach(line);\n  }\n\n  function geometry(o) {\n    if (o.type === \"GeometryCollection\") o.geometries.forEach(geometry);\n    else if (o.type in geometryType) geom = o, geometryType[o.type](o.arcs);\n  }\n\n  if (arguments.length > 1) {\n    var geomsByArc = [],\n        geom;\n\n    var geometryType = {\n      LineString: line,\n      MultiLineString: polygon,\n      Polygon: polygon,\n      MultiPolygon: function(arcs) { arcs.forEach(polygon); }\n    };\n\n    geometry(o);\n\n    geomsByArc.forEach(arguments.length < 3\n        ? function(geoms) { arcs.push(geoms[0].i); }\n        : function(geoms) { if (filter(geoms[0].g, geoms[geoms.length - 1].g)) arcs.push(geoms[0].i); });\n  } else {\n    for (var i = 0, n = topology.arcs.length; i < n; ++i) arcs.push(i);\n  }\n\n  return {type: \"MultiLineString\", arcs: stitchArcs(topology, arcs)};\n}\n\nfunction cartesianTriangleArea(triangle) {\n  var a = triangle[0], b = triangle[1], c = triangle[2];\n  return Math.abs((a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]));\n}\n\nfunction ring(ring) {\n  var i = -1,\n      n = ring.length,\n      a,\n      b = ring[n - 1],\n      area = 0;\n\n  while (++i < n) {\n    a = b;\n    b = ring[i];\n    area += a[0] * b[1] - a[1] * b[0];\n  }\n\n  return area / 2;\n}\n\nfunction merge(topology) {\n  return object(topology, mergeArcs.apply(this, arguments));\n}\n\nfunction mergeArcs(topology, objects) {\n  var polygonsByArc = {},\n      polygons = [],\n      components = [];\n\n  objects.forEach(function(o) {\n    if (o.type === \"Polygon\") register(o.arcs);\n    else if (o.type === \"MultiPolygon\") o.arcs.forEach(register);\n  });\n\n  function register(polygon) {\n    polygon.forEach(function(ring$$) {\n      ring$$.forEach(function(arc) {\n        (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon);\n      });\n    });\n    polygons.push(polygon);\n  }\n\n  function area(ring$$) {\n    return Math.abs(ring(object(topology, {type: \"Polygon\", arcs: [ring$$]}).coordinates[0]));\n  }\n\n  polygons.forEach(function(polygon) {\n    if (!polygon._) {\n      var component = [],\n          neighbors = [polygon];\n      polygon._ = 1;\n      components.push(component);\n      while (polygon = neighbors.pop()) {\n        component.push(polygon);\n        polygon.forEach(function(ring$$) {\n          ring$$.forEach(function(arc) {\n            polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon) {\n              if (!polygon._) {\n                polygon._ = 1;\n                neighbors.push(polygon);\n              }\n            });\n          });\n        });\n      }\n    }\n  });\n\n  polygons.forEach(function(polygon) {\n    delete polygon._;\n  });\n\n  return {\n    type: \"MultiPolygon\",\n    arcs: components.map(function(polygons) {\n      var arcs = [], n;\n\n      // Extract the exterior (unique) arcs.\n      polygons.forEach(function(polygon) {\n        polygon.forEach(function(ring$$) {\n          ring$$.forEach(function(arc) {\n            if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {\n              arcs.push(arc);\n            }\n          });\n        });\n      });\n\n      // Stitch the arcs into one or more rings.\n      arcs = stitchArcs(topology, arcs);\n\n      // If more than one ring is returned,\n      // at most one of these rings can be the exterior;\n      // choose the one with the greatest absolute area.\n      if ((n = arcs.length) > 1) {\n        for (var i = 1, k = area(arcs[0]), ki, t; i < n; ++i) {\n          if ((ki = area(arcs[i])) > k) {\n            t = arcs[0], arcs[0] = arcs[i], arcs[i] = t, k = ki;\n          }\n        }\n      }\n\n      return arcs;\n    })\n  };\n}\n\nfunction neighbors(objects) {\n  var indexesByArc = {}, // arc index -> array of object indexes\n      neighbors = objects.map(function() { return []; });\n\n  function line(arcs, i) {\n    arcs.forEach(function(a) {\n      if (a < 0) a = ~a;\n      var o = indexesByArc[a];\n      if (o) o.push(i);\n      else indexesByArc[a] = [i];\n    });\n  }\n\n  function polygon(arcs, i) {\n    arcs.forEach(function(arc) { line(arc, i); });\n  }\n\n  function geometry(o, i) {\n    if (o.type === \"GeometryCollection\") o.geometries.forEach(function(o) { geometry(o, i); });\n    else if (o.type in geometryType) geometryType[o.type](o.arcs, i);\n  }\n\n  var geometryType = {\n    LineString: line,\n    MultiLineString: polygon,\n    Polygon: polygon,\n    MultiPolygon: function(arcs, i) { arcs.forEach(function(arc) { polygon(arc, i); }); }\n  };\n\n  objects.forEach(geometry);\n\n  for (var i in indexesByArc) {\n    for (var indexes = indexesByArc[i], m = indexes.length, j = 0; j < m; ++j) {\n      for (var k = j + 1; k < m; ++k) {\n        var ij = indexes[j], ik = indexes[k], n;\n        if ((n = neighbors[ij])[i = bisect(n, ik)] !== ik) n.splice(i, 0, ik);\n        if ((n = neighbors[ik])[i = bisect(n, ij)] !== ij) n.splice(i, 0, ij);\n      }\n    }\n  }\n\n  return neighbors;\n}\n\nfunction compareArea(a, b) {\n  return a[1][2] - b[1][2];\n}\n\nfunction minAreaHeap() {\n  var heap = {},\n      array = [],\n      size = 0;\n\n  heap.push = function(object) {\n    up(array[object._ = size] = object, size++);\n    return size;\n  };\n\n  heap.pop = function() {\n    if (size <= 0) return;\n    var removed = array[0], object;\n    if (--size > 0) object = array[size], down(array[object._ = 0] = object, 0);\n    return removed;\n  };\n\n  heap.remove = function(removed) {\n    var i = removed._, object;\n    if (array[i] !== removed) return; // invalid request\n    if (i !== --size) object = array[size], (compareArea(object, removed) < 0 ? up : down)(array[object._ = i] = object, i);\n    return i;\n  };\n\n  function up(object, i) {\n    while (i > 0) {\n      var j = ((i + 1) >> 1) - 1,\n          parent = array[j];\n      if (compareArea(object, parent) >= 0) break;\n      array[parent._ = i] = parent;\n      array[object._ = i = j] = object;\n    }\n  }\n\n  function down(object, i) {\n    while (true) {\n      var r = (i + 1) << 1,\n          l = r - 1,\n          j = i,\n          child = array[j];\n      if (l < size && compareArea(array[l], child) < 0) child = array[j = l];\n      if (r < size && compareArea(array[r], child) < 0) child = array[j = r];\n      if (j === i) break;\n      array[child._ = i] = child;\n      array[object._ = i = j] = object;\n    }\n  }\n\n  return heap;\n}\n\nfunction presimplify(topology, triangleArea) {\n  var absolute = transformAbsolute(topology.transform),\n      relative = transformRelative(topology.transform),\n      heap = minAreaHeap();\n\n  if (!triangleArea) triangleArea = cartesianTriangleArea;\n\n  topology.arcs.forEach(function(arc) {\n    var triangles = [],\n        maxArea = 0,\n        triangle,\n        i,\n        n,\n        p;\n\n    // To store each point’s effective area, we create a new array rather than\n    // extending the passed-in point to workaround a Chrome/V8 bug (getting\n    // stuck in smi mode). For midpoints, the initial effective area of\n    // Infinity will be computed in the next step.\n    for (i = 0, n = arc.length; i < n; ++i) {\n      p = arc[i];\n      absolute(arc[i] = [p[0], p[1], Infinity], i);\n    }\n\n    for (i = 1, n = arc.length - 1; i < n; ++i) {\n      triangle = arc.slice(i - 1, i + 2);\n      triangle[1][2] = triangleArea(triangle);\n      triangles.push(triangle);\n      heap.push(triangle);\n    }\n\n    for (i = 0, n = triangles.length; i < n; ++i) {\n      triangle = triangles[i];\n      triangle.previous = triangles[i - 1];\n      triangle.next = triangles[i + 1];\n    }\n\n    while (triangle = heap.pop()) {\n      var previous = triangle.previous,\n          next = triangle.next;\n\n      // If the area of the current point is less than that of the previous point\n      // to be eliminated, use the latter's area instead. This ensures that the\n      // current point cannot be eliminated without eliminating previously-\n      // eliminated points.\n      if (triangle[1][2] < maxArea) triangle[1][2] = maxArea;\n      else maxArea = triangle[1][2];\n\n      if (previous) {\n        previous.next = next;\n        previous[2] = triangle[2];\n        update(previous);\n      }\n\n      if (next) {\n        next.previous = previous;\n        next[0] = triangle[0];\n        update(next);\n      }\n    }\n\n    arc.forEach(relative);\n  });\n\n  function update(triangle) {\n    heap.remove(triangle);\n    triangle[1][2] = triangleArea(triangle);\n    heap.push(triangle);\n  }\n\n  return topology;\n}\n\nvar version = \"1.6.27\";\n\nexports.version = version;\nexports.mesh = mesh;\nexports.meshArcs = meshArcs;\nexports.merge = merge;\nexports.mergeArcs = mergeArcs;\nexports.feature = feature;\nexports.neighbors = neighbors;\nexports.presimplify = presimplify;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/topojson/build/topojson.js\n ** module id = 26\n ** module chunks = 0\n **/","var normalize = require('geojson-normalize');\n\nmodule.exports = function(inputs) {\n    return {\n        type: 'FeatureCollection',\n        features: inputs.reduce(function(memo, input) {\n            return memo.concat(normalize(input).features);\n        }, [])\n    };\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/geojson-merge/index.js\n ** module id = 27\n ** module chunks = 0\n **/","module.exports = normalize;\n\nvar types = {\n    Point: 'geometry',\n    MultiPoint: 'geometry',\n    LineString: 'geometry',\n    MultiLineString: 'geometry',\n    Polygon: 'geometry',\n    MultiPolygon: 'geometry',\n    GeometryCollection: 'geometry',\n    Feature: 'feature',\n    FeatureCollection: 'featurecollection'\n};\n\n/**\n * Normalize a GeoJSON feature into a FeatureCollection.\n *\n * @param {object} gj geojson data\n * @returns {object} normalized geojson data\n */\nfunction normalize(gj) {\n    if (!gj || !gj.type) return null;\n    var type = types[gj.type];\n    if (!type) return null;\n\n    if (type === 'geometry') {\n        return {\n            type: 'FeatureCollection',\n            features: [{\n                type: 'Feature',\n                properties: {},\n                geometry: gj\n            }]\n        };\n    } else if (type === 'feature') {\n        return {\n            type: 'FeatureCollection',\n            features: [gj]\n        };\n    } else if (type === 'featurecollection') {\n        return gj;\n    }\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/geojson-normalize/index.js\n ** module id = 28\n ** module chunks = 0\n **/","'use strict';\n\nmodule.exports = earcut;\n\nfunction earcut(data, holeIndices, dim) {\n\n    dim = dim || 2;\n\n    var hasHoles = holeIndices && holeIndices.length,\n        outerLen = hasHoles ? holeIndices[0] * dim : data.length,\n        outerNode = linkedList(data, 0, outerLen, dim, true),\n        triangles = [];\n\n    if (!outerNode) return triangles;\n\n    var minX, minY, maxX, maxY, x, y, size;\n\n    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);\n\n    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox\n    if (data.length > 80 * dim) {\n        minX = maxX = data[0];\n        minY = maxY = data[1];\n\n        for (var i = dim; i < outerLen; i += dim) {\n            x = data[i];\n            y = data[i + 1];\n            if (x < minX) minX = x;\n            if (y < minY) minY = y;\n            if (x > maxX) maxX = x;\n            if (y > maxY) maxY = y;\n        }\n\n        // minX, minY and size are later used to transform coords into integers for z-order calculation\n        size = Math.max(maxX - minX, maxY - minY);\n    }\n\n    earcutLinked(outerNode, triangles, dim, minX, minY, size);\n\n    return triangles;\n}\n\n// create a circular doubly linked list from polygon points in the specified winding order\nfunction linkedList(data, start, end, dim, clockwise) {\n    var i, last;\n\n    if (clockwise === (signedArea(data, start, end, dim) > 0)) {\n        for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);\n    } else {\n        for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);\n    }\n\n    if (last && equals(last, last.next)) {\n        removeNode(last);\n        last = last.next;\n    }\n\n    return last;\n}\n\n// eliminate colinear or duplicate points\nfunction filterPoints(start, end) {\n    if (!start) return start;\n    if (!end) end = start;\n\n    var p = start,\n        again;\n    do {\n        again = false;\n\n        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {\n            removeNode(p);\n            p = end = p.prev;\n            if (p === p.next) return null;\n            again = true;\n\n        } else {\n            p = p.next;\n        }\n    } while (again || p !== end);\n\n    return end;\n}\n\n// main ear slicing loop which triangulates a polygon (given as a linked list)\nfunction earcutLinked(ear, triangles, dim, minX, minY, size, pass) {\n    if (!ear) return;\n\n    // interlink polygon nodes in z-order\n    if (!pass && size) indexCurve(ear, minX, minY, size);\n\n    var stop = ear,\n        prev, next;\n\n    // iterate through ears, slicing them one by one\n    while (ear.prev !== ear.next) {\n        prev = ear.prev;\n        next = ear.next;\n\n        if (size ? isEarHashed(ear, minX, minY, size) : isEar(ear)) {\n            // cut off the triangle\n            triangles.push(prev.i / dim);\n            triangles.push(ear.i / dim);\n            triangles.push(next.i / dim);\n\n            removeNode(ear);\n\n            // skipping the next vertice leads to less sliver triangles\n            ear = next.next;\n            stop = next.next;\n\n            continue;\n        }\n\n        ear = next;\n\n        // if we looped through the whole remaining polygon and can't find any more ears\n        if (ear === stop) {\n            // try filtering points and slicing again\n            if (!pass) {\n                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, size, 1);\n\n            // if this didn't work, try curing all small self-intersections locally\n            } else if (pass === 1) {\n                ear = cureLocalIntersections(ear, triangles, dim);\n                earcutLinked(ear, triangles, dim, minX, minY, size, 2);\n\n            // as a last resort, try splitting the remaining polygon into two\n            } else if (pass === 2) {\n                splitEarcut(ear, triangles, dim, minX, minY, size);\n            }\n\n            break;\n        }\n    }\n}\n\n// check whether a polygon node forms a valid ear with adjacent nodes\nfunction isEar(ear) {\n    var a = ear.prev,\n        b = ear,\n        c = ear.next;\n\n    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear\n\n    // now make sure we don't have other points inside the potential ear\n    var p = ear.next.next;\n\n    while (p !== ear.prev) {\n        if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&\n            area(p.prev, p, p.next) >= 0) return false;\n        p = p.next;\n    }\n\n    return true;\n}\n\nfunction isEarHashed(ear, minX, minY, size) {\n    var a = ear.prev,\n        b = ear,\n        c = ear.next;\n\n    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear\n\n    // triangle bbox; min & max are calculated like this for speed\n    var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x),\n        minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y),\n        maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x),\n        maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y);\n\n    // z-order range for the current triangle bbox;\n    var minZ = zOrder(minTX, minTY, minX, minY, size),\n        maxZ = zOrder(maxTX, maxTY, minX, minY, size);\n\n    // first look for points inside the triangle in increasing z-order\n    var p = ear.nextZ;\n\n    while (p && p.z <= maxZ) {\n        if (p !== ear.prev && p !== ear.next &&\n            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&\n            area(p.prev, p, p.next) >= 0) return false;\n        p = p.nextZ;\n    }\n\n    // then look for points in decreasing z-order\n    p = ear.prevZ;\n\n    while (p && p.z >= minZ) {\n        if (p !== ear.prev && p !== ear.next &&\n            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&\n            area(p.prev, p, p.next) >= 0) return false;\n        p = p.prevZ;\n    }\n\n    return true;\n}\n\n// go through all polygon nodes and cure small local self-intersections\nfunction cureLocalIntersections(start, triangles, dim) {\n    var p = start;\n    do {\n        var a = p.prev,\n            b = p.next.next;\n\n        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {\n\n            triangles.push(a.i / dim);\n            triangles.push(p.i / dim);\n            triangles.push(b.i / dim);\n\n            // remove two nodes involved\n            removeNode(p);\n            removeNode(p.next);\n\n            p = start = b;\n        }\n        p = p.next;\n    } while (p !== start);\n\n    return p;\n}\n\n// try splitting polygon into two and triangulate them independently\nfunction splitEarcut(start, triangles, dim, minX, minY, size) {\n    // look for a valid diagonal that divides the polygon into two\n    var a = start;\n    do {\n        var b = a.next.next;\n        while (b !== a.prev) {\n            if (a.i !== b.i && isValidDiagonal(a, b)) {\n                // split the polygon in two by the diagonal\n                var c = splitPolygon(a, b);\n\n                // filter colinear points around the cuts\n                a = filterPoints(a, a.next);\n                c = filterPoints(c, c.next);\n\n                // run earcut on each half\n                earcutLinked(a, triangles, dim, minX, minY, size);\n                earcutLinked(c, triangles, dim, minX, minY, size);\n                return;\n            }\n            b = b.next;\n        }\n        a = a.next;\n    } while (a !== start);\n}\n\n// link every hole into the outer loop, producing a single-ring polygon without holes\nfunction eliminateHoles(data, holeIndices, outerNode, dim) {\n    var queue = [],\n        i, len, start, end, list;\n\n    for (i = 0, len = holeIndices.length; i < len; i++) {\n        start = holeIndices[i] * dim;\n        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;\n        list = linkedList(data, start, end, dim, false);\n        if (list === list.next) list.steiner = true;\n        queue.push(getLeftmost(list));\n    }\n\n    queue.sort(compareX);\n\n    // process holes from left to right\n    for (i = 0; i < queue.length; i++) {\n        eliminateHole(queue[i], outerNode);\n        outerNode = filterPoints(outerNode, outerNode.next);\n    }\n\n    return outerNode;\n}\n\nfunction compareX(a, b) {\n    return a.x - b.x;\n}\n\n// find a bridge between vertices that connects hole with an outer ring and and link it\nfunction eliminateHole(hole, outerNode) {\n    outerNode = findHoleBridge(hole, outerNode);\n    if (outerNode) {\n        var b = splitPolygon(outerNode, hole);\n        filterPoints(b, b.next);\n    }\n}\n\n// David Eberly's algorithm for finding a bridge between hole and outer polygon\nfunction findHoleBridge(hole, outerNode) {\n    var p = outerNode,\n        hx = hole.x,\n        hy = hole.y,\n        qx = -Infinity,\n        m;\n\n    // find a segment intersected by a ray from the hole's leftmost point to the left;\n    // segment's endpoint with lesser x will be potential connection point\n    do {\n        if (hy <= p.y && hy >= p.next.y) {\n            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);\n            if (x <= hx && x > qx) {\n                qx = x;\n                if (x === hx) {\n                    if (hy === p.y) return p;\n                    if (hy === p.next.y) return p.next;\n                }\n                m = p.x < p.next.x ? p : p.next;\n            }\n        }\n        p = p.next;\n    } while (p !== outerNode);\n\n    if (!m) return null;\n\n    if (hx === qx) return m.prev; // hole touches outer segment; pick lower endpoint\n\n    // look for points inside the triangle of hole point, segment intersection and endpoint;\n    // if there are no points found, we have a valid connection;\n    // otherwise choose the point of the minimum angle with the ray as connection point\n\n    var stop = m,\n        mx = m.x,\n        my = m.y,\n        tanMin = Infinity,\n        tan;\n\n    p = m.next;\n\n    while (p !== stop) {\n        if (hx >= p.x && p.x >= mx &&\n                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {\n\n            tan = Math.abs(hy - p.y) / (hx - p.x); // tangential\n\n            if ((tan < tanMin || (tan === tanMin && p.x > m.x)) && locallyInside(p, hole)) {\n                m = p;\n                tanMin = tan;\n            }\n        }\n\n        p = p.next;\n    }\n\n    return m;\n}\n\n// interlink polygon nodes in z-order\nfunction indexCurve(start, minX, minY, size) {\n    var p = start;\n    do {\n        if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, size);\n        p.prevZ = p.prev;\n        p.nextZ = p.next;\n        p = p.next;\n    } while (p !== start);\n\n    p.prevZ.nextZ = null;\n    p.prevZ = null;\n\n    sortLinked(p);\n}\n\n// Simon Tatham's linked list merge sort algorithm\n// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html\nfunction sortLinked(list) {\n    var i, p, q, e, tail, numMerges, pSize, qSize,\n        inSize = 1;\n\n    do {\n        p = list;\n        list = null;\n        tail = null;\n        numMerges = 0;\n\n        while (p) {\n            numMerges++;\n            q = p;\n            pSize = 0;\n            for (i = 0; i < inSize; i++) {\n                pSize++;\n                q = q.nextZ;\n                if (!q) break;\n            }\n\n            qSize = inSize;\n\n            while (pSize > 0 || (qSize > 0 && q)) {\n\n                if (pSize === 0) {\n                    e = q;\n                    q = q.nextZ;\n                    qSize--;\n                } else if (qSize === 0 || !q) {\n                    e = p;\n                    p = p.nextZ;\n                    pSize--;\n                } else if (p.z <= q.z) {\n                    e = p;\n                    p = p.nextZ;\n                    pSize--;\n                } else {\n                    e = q;\n                    q = q.nextZ;\n                    qSize--;\n                }\n\n                if (tail) tail.nextZ = e;\n                else list = e;\n\n                e.prevZ = tail;\n                tail = e;\n            }\n\n            p = q;\n        }\n\n        tail.nextZ = null;\n        inSize *= 2;\n\n    } while (numMerges > 1);\n\n    return list;\n}\n\n// z-order of a point given coords and size of the data bounding box\nfunction zOrder(x, y, minX, minY, size) {\n    // coords are transformed into non-negative 15-bit integer range\n    x = 32767 * (x - minX) / size;\n    y = 32767 * (y - minY) / size;\n\n    x = (x | (x << 8)) & 0x00FF00FF;\n    x = (x | (x << 4)) & 0x0F0F0F0F;\n    x = (x | (x << 2)) & 0x33333333;\n    x = (x | (x << 1)) & 0x55555555;\n\n    y = (y | (y << 8)) & 0x00FF00FF;\n    y = (y | (y << 4)) & 0x0F0F0F0F;\n    y = (y | (y << 2)) & 0x33333333;\n    y = (y | (y << 1)) & 0x55555555;\n\n    return x | (y << 1);\n}\n\n// find the leftmost node of a polygon ring\nfunction getLeftmost(start) {\n    var p = start,\n        leftmost = start;\n    do {\n        if (p.x < leftmost.x) leftmost = p;\n        p = p.next;\n    } while (p !== start);\n\n    return leftmost;\n}\n\n// check if a point lies within a convex triangle\nfunction pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {\n    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&\n           (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&\n           (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;\n}\n\n// check if a diagonal between two polygon nodes is valid (lies in polygon interior)\nfunction isValidDiagonal(a, b) {\n    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) &&\n           locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);\n}\n\n// signed area of a triangle\nfunction area(p, q, r) {\n    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);\n}\n\n// check if two points are equal\nfunction equals(p1, p2) {\n    return p1.x === p2.x && p1.y === p2.y;\n}\n\n// check if two segments intersect\nfunction intersects(p1, q1, p2, q2) {\n    if ((equals(p1, q1) && equals(p2, q2)) ||\n        (equals(p1, q2) && equals(p2, q1))) return true;\n    return area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 &&\n           area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0;\n}\n\n// check if a polygon diagonal intersects any polygon segments\nfunction intersectsPolygon(a, b) {\n    var p = a;\n    do {\n        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&\n                intersects(p, p.next, a, b)) return true;\n        p = p.next;\n    } while (p !== a);\n\n    return false;\n}\n\n// check if a polygon diagonal is locally inside the polygon\nfunction locallyInside(a, b) {\n    return area(a.prev, a, a.next) < 0 ?\n        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :\n        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;\n}\n\n// check if the middle point of a polygon diagonal is inside the polygon\nfunction middleInside(a, b) {\n    var p = a,\n        inside = false,\n        px = (a.x + b.x) / 2,\n        py = (a.y + b.y) / 2;\n    do {\n        if (((p.y > py) !== (p.next.y > py)) && (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))\n            inside = !inside;\n        p = p.next;\n    } while (p !== a);\n\n    return inside;\n}\n\n// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;\n// if one belongs to the outer ring and another to a hole, it merges it into a single ring\nfunction splitPolygon(a, b) {\n    var a2 = new Node(a.i, a.x, a.y),\n        b2 = new Node(b.i, b.x, b.y),\n        an = a.next,\n        bp = b.prev;\n\n    a.next = b;\n    b.prev = a;\n\n    a2.next = an;\n    an.prev = a2;\n\n    b2.next = a2;\n    a2.prev = b2;\n\n    bp.next = b2;\n    b2.prev = bp;\n\n    return b2;\n}\n\n// create a node and optionally link it with previous one (in a circular doubly linked list)\nfunction insertNode(i, x, y, last) {\n    var p = new Node(i, x, y);\n\n    if (!last) {\n        p.prev = p;\n        p.next = p;\n\n    } else {\n        p.next = last.next;\n        p.prev = last;\n        last.next.prev = p;\n        last.next = p;\n    }\n    return p;\n}\n\nfunction removeNode(p) {\n    p.next.prev = p.prev;\n    p.prev.next = p.next;\n\n    if (p.prevZ) p.prevZ.nextZ = p.nextZ;\n    if (p.nextZ) p.nextZ.prevZ = p.prevZ;\n}\n\nfunction Node(i, x, y) {\n    // vertice index in coordinates array\n    this.i = i;\n\n    // vertex coordinates\n    this.x = x;\n    this.y = y;\n\n    // previous and next vertice nodes in a polygon ring\n    this.prev = null;\n    this.next = null;\n\n    // z-order curve value\n    this.z = null;\n\n    // previous and next nodes in z-order\n    this.prevZ = null;\n    this.nextZ = null;\n\n    // indicates whether this is a steiner point\n    this.steiner = false;\n}\n\n// return a percentage difference between the polygon area and its triangulation area;\n// used to verify correctness of triangulation\nearcut.deviation = function (data, holeIndices, dim, triangles) {\n    var hasHoles = holeIndices && holeIndices.length;\n    var outerLen = hasHoles ? holeIndices[0] * dim : data.length;\n\n    var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));\n    if (hasHoles) {\n        for (var i = 0, len = holeIndices.length; i < len; i++) {\n            var start = holeIndices[i] * dim;\n            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;\n            polygonArea -= Math.abs(signedArea(data, start, end, dim));\n        }\n    }\n\n    var trianglesArea = 0;\n    for (i = 0; i < triangles.length; i += 3) {\n        var a = triangles[i] * dim;\n        var b = triangles[i + 1] * dim;\n        var c = triangles[i + 2] * dim;\n        trianglesArea += Math.abs(\n            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -\n            (data[a] - data[b]) * (data[c + 1] - data[a + 1]));\n    }\n\n    return polygonArea === 0 && trianglesArea === 0 ? 0 :\n        Math.abs((trianglesArea - polygonArea) / polygonArea);\n};\n\nfunction signedArea(data, start, end, dim) {\n    var sum = 0;\n    for (var i = start, j = end - dim; i < end; i += dim) {\n        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);\n        j = i;\n    }\n    return sum;\n}\n\n// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts\nearcut.flatten = function (data) {\n    var dim = data[0][0].length,\n        result = {vertices: [], holes: [], dimensions: dim},\n        holeIndex = 0;\n\n    for (var i = 0; i < data.length; i++) {\n        for (var j = 0; j < data[i].length; j++) {\n            for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);\n        }\n        if (i > 0) {\n            holeIndex += data[i - 1].length;\n            result.holes.push(holeIndex);\n        }\n    }\n    return result;\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/earcut/src/earcut.js\n ** module id = 29\n ** module chunks = 0\n **/","/*\n * Extrude a polygon given its vertices and triangulated faces\n *\n * Based on:\n * https://github.com/freeman-lab/extrude\n */\n\nimport extend from 'lodash.assign';\n\nvar extrudePolygon = function(points, faces, _options) {\n  var defaults = {\n    top: 1,\n    bottom: 0,\n    closed: true\n  };\n\n  var options = extend({}, defaults, _options);\n\n  var n = points.length;\n  var positions;\n  var cells;\n  var topCells;\n  var bottomCells;\n  var sideCells;\n\n  // If bottom and top values are identical then return the flat shape\n  (options.top === options.bottom) ? flat() : full();\n\n  function flat() {\n    positions = points.map(function(p) { return [p[0], options.top, p[1]]; });\n    cells = faces;\n    topCells = faces;\n  }\n\n  function full() {\n    positions = [];\n    points.forEach(function(p) { positions.push([p[0], options.top, p[1]]); });\n    points.forEach(function(p) { positions.push([p[0], options.bottom, p[1]]); });\n\n    cells = [];\n    for (var i = 0; i < n; i++) {\n      if (i === (n - 1)) {\n        cells.push([i + n, n, i]);\n        cells.push([0, i, n]);\n      } else {\n        cells.push([i + n, i + n + 1, i]);\n        cells.push([i + 1, i, i + n + 1]);\n      }\n    }\n\n    sideCells = [].concat(cells);\n\n    if (options.closed) {\n      var top = faces;\n      var bottom = top.map(function(p) { return p.map(function(v) { return v + n; }); });\n      bottom = bottom.map(function(p) { return [p[0], p[2], p[1]]; });\n      cells = cells.concat(top).concat(bottom);\n\n      topCells = top;\n      bottomCells = bottom;\n    }\n  }\n\n  return {\n    positions: positions,\n    faces: cells,\n    top: topCells,\n    bottom: bottomCells,\n    sides: sideCells\n  };\n};\n\nexport default extrudePolygon;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/extrudePolygon.js\n **/","import WorkerPool from './WorkerPool';\n\nvar Worker = (function() {\n  var _maxWorkers = 2;\n  var pool;\n\n  var createWorkers = function(maxWorkers, workerScript) {\n    pool = new WorkerPool({\n      numThreads: (maxWorkers) ? maxWorkers : _maxWorkers,\n      workerScript: (workerScript) ? workerScript : 'vizicities-worker.js'\n    });\n\n    return pool.createWorkers();\n  };\n\n  var exec = function(method, args, transferrables) {\n    return pool.exec(method, args, transferrables);\n  };\n\n  return {\n    createWorkers: createWorkers,\n    exec: exec\n  };\n})();\n\nexport default Worker;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/Worker.js\n **/","import WorkerPoolWorker from './WorkerPoolWorker';\n\nconst DEBUG = false;\n\nclass WorkerPool {\n  constructor(options) {\n    this.numThreads = options.numThreads || 2;\n    this.workerScript = options.workerScript;\n\n    this.workers = [];\n    this.tasks = [];\n  }\n\n  createWorkers() {\n    return new Promise((resolve, reject) => {\n      var workerPromises = [];\n\n      for (var i = 0; i < this.numThreads; i++) {\n        workerPromises.push(this.createWorker());\n      }\n\n      Promise.all(workerPromises).then(() => {\n        if (DEBUG) { console.log('All workers ready', performance.now()); }\n        resolve();\n      }).catch(reject);\n    });\n  }\n\n  createWorker() {\n    return new Promise((resolve, reject) => {\n      // Initialise worker\n      var worker = new WorkerPoolWorker({\n        workerScript: this.workerScript\n      });\n\n      // Start worker and wait for it to be ready\n      return worker.start().then(() => {\n        if (DEBUG) { console.log('Worker ready', performance.now()); }\n\n        // Add worker to pool\n        this.workers.push(worker);\n\n        resolve();\n      }).catch(reject);\n    });\n  }\n\n  getFreeWorker() {\n    return this.workers.find((worker) => {\n      return !worker.busy;\n    });\n  }\n\n  // Execute task on a worker\n  exec(method, args, transferrables) {\n    var deferred = Promise.deferred();\n\n    // Create task\n    var task = {\n      method: method,\n      args: args,\n      transferrables: transferrables,\n      deferred: deferred\n    };\n\n    // Add task to queue\n    this.tasks.push(task);\n\n    // Trigger task processing\n    this.processTasks();\n\n    // Return task promise\n    return task.deferred.promise;\n  }\n\n  processTasks() {\n    if (DEBUG) { console.log('Processing tasks'); }\n\n    if (this.tasks.length === 0) {\n      return;\n    }\n\n    // Find free worker\n    var worker = this.getFreeWorker();\n\n    if (!worker) {\n      if (DEBUG) { console.log('No workers free'); }\n      return;\n    }\n\n    // Get oldest task\n    var task = this.tasks.shift();\n\n    // Execute task on worker\n    worker.exec(task.method, task.args, task.transferrables).then((result) => {\n      // Trigger task processing\n      this.processTasks();\n\n      // Return result in deferred task promise\n      task.deferred.resolve(result);\n    });\n  }\n}\n\nexport default WorkerPool;\n\n// Quick shim to create deferred native promises\nPromise.deferred = function() {\n  var result = {};\n\n  result.promise = new Promise((resolve, reject) => {\n    result.resolve = resolve;\n    result.reject = reject;\n  });\n\n  return result;\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/WorkerPool.js\n **/","const DEBUG = false;\n\nclass WorkerPoolWorker {\n  constructor(options) {\n    this.workerScript = options.workerScript;\n\n    this.ready = false;\n    this.busy = false;\n    this.deferred = null;\n  }\n\n  start() {\n    return new Promise((resolve, reject) => {\n      this.worker = new Worker(this.workerScript);\n\n      var onStartup = (event) => {\n        if (!event.data || event.data.type !== 'startup') {\n          reject();\n          return;\n        }\n\n        this.ready = true;\n\n        // Remove temporary message handler\n        this.worker.removeEventListener('message', onStartup);\n\n        // Set up listener to respond to normal events now\n        this.worker.addEventListener('message', (event) => {\n          this.onMessage(event);\n        });\n\n        // Resolve once worker is ready\n        resolve();\n      };\n\n      // Set up temporary event listener for warmup\n      this.worker.addEventListener('message', onStartup);\n    });\n  }\n\n  exec(method, args, transferrables) {\n    if (DEBUG) { console.log('Execute', method, args, transferrables); }\n\n    var deferred = Promise.deferred();\n\n    this.busy = true;\n    this.deferred = deferred;\n\n    this.worker.postMessage({\n      method: method,\n      args: args\n    }, transferrables);\n\n    return deferred.promise;\n  }\n\n  onMessage(event) {\n    console.log('Message received from worker', performance.now());\n\n    this.busy = false;\n\n    if (!event.data || event.data.type === 'error' || event.data.type !== 'result') {\n      this.deferred.reject(event.data.payload);\n      return;\n    }\n\n    this.deferred.resolve(event.data.payload);\n  }\n}\n\nexport default WorkerPoolWorker;\n\n// Quick shim to create deferred native promises\nPromise.deferred = function() {\n  var result = {};\n\n  result.promise = new Promise((resolve, reject) => {\n    result.resolve = resolve;\n    result.reject = reject;\n  });\n\n  return result;\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/WorkerPoolWorker.js\n **/","/*\n * BufferGeometry helpers\n */\n\nimport THREE from 'three';\n\nvar Buffer = (function() {\n  // Merge TypedArrays of the same type\n  // Returns merged array as well as indexes for splitting the array\n  var mergeFloat32Arrays = function(arrays) {\n    var size = 0;\n    var map = new Int32Array(arrays.length * 2);\n\n    var lastIndex = 0;\n    var length;\n\n    // Find size of each array\n    arrays.forEach((_array, index) => {\n      length = _array.length;\n      size += length;\n      map.set([lastIndex, lastIndex + length], index * 2);\n      lastIndex += length;\n    });\n\n    // Create a new array of total size\n    var mergedArray = new Float32Array(size);\n\n    // Add each array to the new array\n    arrays.forEach((_array, index) => {\n      mergedArray.set(_array, map[index * 2]);\n    });\n\n    return [\n      mergedArray,\n      map\n    ];\n  };\n\n  var splitFloat32Array = function(data) {\n    var arr = data[0];\n    var map = data[1];\n\n    var start;\n    var arrays = [];\n\n    // Iterate over map\n    for (var i = 0; i < map.length / 2; i++) {\n      start = i * 2;\n      arrays.push(arr.subarray(map[start], map[start + 1]));\n    }\n\n    return arrays;\n  };\n\n  // TODO: Create a generic method that can work for any typed array\n  var mergeUint8Arrays = function(arrays) {\n    var size = 0;\n    var map = new Int32Array(arrays.length * 2);\n\n    var lastIndex = 0;\n    var length;\n\n    // Find size of each array\n    arrays.forEach((_array, index) => {\n      length = _array.length;\n      size += length;\n      map.set([lastIndex, lastIndex + length], index * 2);\n      lastIndex += length;\n    });\n\n    // Create a new array of total size\n    var mergedArray = new Uint8Array(size);\n\n    // Add each array to the new array\n    arrays.forEach((_array, index) => {\n      mergedArray.set(_array, map[index * 2]);\n    });\n\n    return [\n      mergedArray,\n      map\n    ];\n  };\n\n  // TODO: Dedupe with splitFloat32Array\n  var splitUint8Array = function(data) {\n    var arr = data[0];\n    var map = data[1];\n\n    var start;\n    var arrays = [];\n\n    // Iterate over map\n    for (var i = 0; i < map.length / 2; i++) {\n      start = i * 2;\n      arrays.push(arr.subarray(map[start], map[start + 1]));\n    }\n\n    return arrays;\n  };\n\n  // Merge multiple attribute objects into a single attribute object\n  //\n  // Attribute objects must all use the same attribute keys\n  var mergeAttributes = function(attributes) {\n    var lengths = {};\n\n    // Find array lengths\n    attributes.forEach(_attributes => {\n      for (var k in _attributes) {\n        if (!lengths[k]) {\n          lengths[k] = 0;\n        }\n\n        lengths[k] += _attributes[k].length;\n      }\n    });\n\n    var mergedAttributes = {};\n\n    // Set up arrays to merge into\n    for (var k in lengths) {\n      mergedAttributes[k] = new Float32Array(lengths[k]);\n    }\n\n    var lastLengths = {};\n\n    attributes.forEach(_attributes => {\n      for (var k in _attributes) {\n        if (!lastLengths[k]) {\n          lastLengths[k] = 0;\n        }\n\n        mergedAttributes[k].set(_attributes[k], lastLengths[k]);\n\n        lastLengths[k] += _attributes[k].length;\n      }\n    });\n\n    return mergedAttributes;\n  };\n\n  var createLineGeometry = function(lines, offset) {\n    var geometry = new THREE.BufferGeometry();\n\n    var vertices = new Float32Array(lines.verticesCount * 3);\n    var colours = new Float32Array(lines.verticesCount * 3);\n\n    var pickingIds;\n    if (lines.pickingIds) {\n      // One component per vertex (1)\n      pickingIds = new Float32Array(lines.verticesCount);\n    }\n\n    var _vertices;\n    var _colour;\n    var _pickingId;\n\n    var lastIndex = 0;\n\n    for (var i = 0; i < lines.vertices.length; i++) {\n      _vertices = lines.vertices[i];\n      _colour = lines.colours[i];\n\n      if (pickingIds) {\n        _pickingId = lines.pickingIds[i];\n      }\n\n      for (var j = 0; j < _vertices.length; j++) {\n        var ax = _vertices[j][0] + offset.x;\n        var ay = _vertices[j][1];\n        var az = _vertices[j][2] + offset.y;\n\n        var c1 = _colour[j];\n\n        vertices[lastIndex * 3 + 0] = ax;\n        vertices[lastIndex * 3 + 1] = ay;\n        vertices[lastIndex * 3 + 2] = az;\n\n        colours[lastIndex * 3 + 0] = c1[0];\n        colours[lastIndex * 3 + 1] = c1[1];\n        colours[lastIndex * 3 + 2] = c1[2];\n\n        if (pickingIds) {\n          pickingIds[lastIndex] = _pickingId;\n        }\n\n        lastIndex++;\n      }\n    }\n\n    // itemSize = 3 because there are 3 values (components) per vertex\n    geometry.addAttribute('position', new THREE.BufferAttribute(vertices, 3));\n    geometry.addAttribute('color', new THREE.BufferAttribute(colours, 3));\n\n    if (pickingIds) {\n      geometry.addAttribute('pickingId', new THREE.BufferAttribute(pickingIds, 1));\n    }\n\n    geometry.computeBoundingBox();\n\n    return geometry;\n  };\n\n  // TODO: Make picking IDs optional\n  var createGeometry = function(attributes, offset) {\n    var geometry = new THREE.BufferGeometry();\n\n    // Three components per vertex per face (3 x 3 = 9)\n    var vertices = new Float32Array(attributes.facesCount * 9);\n    var normals = new Float32Array(attributes.facesCount * 9);\n    var colours = new Float32Array(attributes.facesCount * 9);\n\n    var pickingIds;\n    if (attributes.pickingIds) {\n      // One component per vertex per face (1 x 3 = 3)\n      pickingIds = new Float32Array(attributes.facesCount * 3);\n    }\n\n    var pA = new THREE.Vector3();\n    var pB = new THREE.Vector3();\n    var pC = new THREE.Vector3();\n\n    var cb = new THREE.Vector3();\n    var ab = new THREE.Vector3();\n\n    var index;\n    var _faces;\n    var _vertices;\n    var _colour;\n    var _pickingId;\n    var lastIndex = 0;\n    for (var i = 0; i < attributes.faces.length; i++) {\n      _faces = attributes.faces[i];\n      _vertices = attributes.vertices[i];\n      _colour = attributes.colours[i];\n\n      if (pickingIds) {\n        _pickingId = attributes.pickingIds[i];\n      }\n\n      for (var j = 0; j < _faces.length; j++) {\n        // Array of vertex indexes for the face\n        index = _faces[j][0];\n\n        var ax = _vertices[index][0] + offset.x;\n        var ay = _vertices[index][1];\n        var az = _vertices[index][2] + offset.y;\n\n        var c1 = _colour[j][0];\n\n        index = _faces[j][1];\n\n        var bx = _vertices[index][0] + offset.x;\n        var by = _vertices[index][1];\n        var bz = _vertices[index][2] + offset.y;\n\n        var c2 = _colour[j][1];\n\n        index = _faces[j][2];\n\n        var cx = _vertices[index][0] + offset.x;\n        var cy = _vertices[index][1];\n        var cz = _vertices[index][2] + offset.y;\n\n        var c3 = _colour[j][2];\n\n        // Flat face normals\n        // From: http://threejs.org/examples/webgl_buffergeometry.html\n        pA.set(ax, ay, az);\n        pB.set(bx, by, bz);\n        pC.set(cx, cy, cz);\n\n        cb.subVectors(pC, pB);\n        ab.subVectors(pA, pB);\n        cb.cross(ab);\n\n        cb.normalize();\n\n        var nx = cb.x;\n        var ny = cb.y;\n        var nz = cb.z;\n\n        vertices[lastIndex * 9 + 0] = ax;\n        vertices[lastIndex * 9 + 1] = ay;\n        vertices[lastIndex * 9 + 2] = az;\n\n        normals[lastIndex * 9 + 0] = nx;\n        normals[lastIndex * 9 + 1] = ny;\n        normals[lastIndex * 9 + 2] = nz;\n\n        colours[lastIndex * 9 + 0] = c1[0];\n        colours[lastIndex * 9 + 1] = c1[1];\n        colours[lastIndex * 9 + 2] = c1[2];\n\n        vertices[lastIndex * 9 + 3] = bx;\n        vertices[lastIndex * 9 + 4] = by;\n        vertices[lastIndex * 9 + 5] = bz;\n\n        normals[lastIndex * 9 + 3] = nx;\n        normals[lastIndex * 9 + 4] = ny;\n        normals[lastIndex * 9 + 5] = nz;\n\n        colours[lastIndex * 9 + 3] = c2[0];\n        colours[lastIndex * 9 + 4] = c2[1];\n        colours[lastIndex * 9 + 5] = c2[2];\n\n        vertices[lastIndex * 9 + 6] = cx;\n        vertices[lastIndex * 9 + 7] = cy;\n        vertices[lastIndex * 9 + 8] = cz;\n\n        normals[lastIndex * 9 + 6] = nx;\n        normals[lastIndex * 9 + 7] = ny;\n        normals[lastIndex * 9 + 8] = nz;\n\n        colours[lastIndex * 9 + 6] = c3[0];\n        colours[lastIndex * 9 + 7] = c3[1];\n        colours[lastIndex * 9 + 8] = c3[2];\n\n        if (pickingIds) {\n          pickingIds[lastIndex * 3 + 0] = _pickingId;\n          pickingIds[lastIndex * 3 + 1] = _pickingId;\n          pickingIds[lastIndex * 3 + 2] = _pickingId;\n        }\n\n        lastIndex++;\n      }\n    }\n\n    // itemSize = 3 because there are 3 values (components) per vertex\n    geometry.addAttribute('position', new THREE.BufferAttribute(vertices, 3));\n    geometry.addAttribute('normal', new THREE.BufferAttribute(normals, 3));\n    geometry.addAttribute('color', new THREE.BufferAttribute(colours, 3));\n\n    if (pickingIds) {\n      geometry.addAttribute('pickingId', new THREE.BufferAttribute(pickingIds, 1));\n    }\n\n    geometry.computeBoundingBox();\n\n    return geometry;\n  };\n\n  var textEncoder = new TextEncoder('utf-8');\n  var textDecoder = new TextDecoder('utf-8');\n\n  var stringToUint8Array = function(str) {\n    return textEncoder.encode(str);\n  };\n\n  var uint8ArrayToString = function(ab) {\n    return textDecoder.decode(ab);\n  };\n\n  return {\n    mergeFloat32Arrays: mergeFloat32Arrays,\n    splitFloat32Array: splitFloat32Array,\n    mergeUint8Arrays: mergeUint8Arrays,\n    splitUint8Array: splitUint8Array,\n    mergeAttributes: mergeAttributes,\n    createLineGeometry: createLineGeometry,\n    createGeometry: createGeometry,\n    stringToUint8Array: stringToUint8Array,\n    uint8ArrayToString: uint8ArrayToString\n  };\n})();\n\nexport default Buffer;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/Buffer.js\n **/","var Stringify = (function() {\n  var functionToString = function(f) {\n    return f.toString();\n  };\n\n  // Based on https://github.com/tangrams/tangram/blob/2a31893c814cf15d5077f87ffa10af20160716b9/src/utils/utils.js#L245\n  var stringToFunction = function(str) {\n    if (typeof str === 'string' && str.match(/^\\s*function\\s*\\w*\\s*\\([\\s\\S]*\\)\\s*\\{[\\s\\S]*\\}/m) != null) {\n      var f;\n\n      try {\n        eval('f = ' + str);\n        return f;\n      } catch (err) {\n        return str;\n      }\n    }\n  };\n\n  return {\n    functionToString: functionToString,\n    stringToFunction: stringToFunction\n  };\n})();\n\nexport default Stringify;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/Stringify.js\n **/","// TODO: Move duplicated logic between geometry layrs into GeometryLayer\n\n// TODO: Look at ways to drop unneeded references to array buffers, etc to\n// reduce memory footprint\n\n// TODO: Support dynamic updating / hiding / animation of geometry\n//\n// This could be pretty hard as it's all packed away within BufferGeometry and\n// may even be merged by another layer (eg. GeoJSONLayer)\n//\n// How much control should this layer support? Perhaps a different or custom\n// layer would be better suited for animation, for example.\n\n// TODO: Allow _setBufferAttributes to use a custom function passed in to\n// generate a custom mesh\n\nimport Layer from '../Layer';\nimport extend from 'lodash.assign';\nimport THREE from 'three';\nimport Geo from '../../geo/Geo';\nimport {latLon as LatLon} from '../../geo/LatLon';\nimport {point as Point} from '../../geo/Point';\nimport earcut from 'earcut';\nimport extrudePolygon from '../../util/extrudePolygon';\nimport PickingMaterial from '../../engine/PickingMaterial';\nimport Buffer from '../../util/Buffer';\n\nclass PolygonLayer extends Layer {\n  constructor(coordinates, options) {\n    var defaults = {\n      output: true,\n      interactive: false,\n      // Custom material override\n      //\n      // TODO: Should this be in the style object?\n      polygonMaterial: null,\n      onPolygonMesh: null,\n      onBufferAttributes: null,\n      // This default style is separate to Util.GeoJSON.defaultStyle\n      style: {\n        color: '#ffffff',\n        transparent: false,\n        opacity: 1,\n        blending: THREE.NormalBlending,\n        height: 0\n      }\n    };\n\n    var _options = extend({}, defaults, options);\n\n    super(_options);\n\n    // Return coordinates as array of polygons so it's easy to support\n    // MultiPolygon features (a single polygon would be a MultiPolygon with a\n    // single polygon in the array)\n    this._coordinates = (PolygonLayer.isSingle(coordinates)) ? [coordinates] : coordinates;\n  }\n\n  _onAdd(world) {\n    return new Promise((resolve, reject) => {\n      this._setCoordinates();\n\n      if (this._options.interactive) {\n        // Only add to picking mesh if this layer is controlling output\n        //\n        // Otherwise, assume another component will eventually add a mesh to\n        // the picking scene\n        if (this.isOutput()) {\n          this._pickingMesh = new THREE.Object3D();\n          this.addToPicking(this._pickingMesh);\n        }\n\n        this._setPickingId();\n        this._addPickingEvents();\n      }\n\n      PolygonLayer.SetBufferAttributes(this._projectedCoordinates, this._options).then((result) => {\n        this._bufferAttributes = Buffer.mergeAttributes(result.attributes);\n\n        if (result.outlineAttributes.length > 0) {\n          this._outlineBufferAttributes = Buffer.mergeAttributes(result.outlineAttributes);\n        }\n\n        this._flat = result.flat;\n\n        if (this.isOutput()) {\n          var attributeLengths = {\n            positions: 3,\n            normals: 3,\n            colors: 3,\n            tops: 1\n          };\n\n          if (this._options.interactive) {\n            attributeLengths.pickingIds = 1;\n          }\n\n          var style = this._options.style;\n\n          // Set mesh if not merging elsewhere\n          PolygonLayer.SetMesh(this._bufferAttributes, attributeLengths, this._flat, style, this._options, this._world._environment._skybox).then((result) => {\n            // Output mesh\n            this.add(result.mesh);\n\n            if (result.pickingMesh) {\n              this._pickingMesh.add(result.pickingMesh);\n            }\n          });\n        }\n\n        result.attributes = null;\n        result.outlineAttributes = null;\n        result = null;\n\n        resolve(this);\n      }).catch(reject);\n    });\n  }\n\n  // Return center of polygon as a LatLon\n  //\n  // This is used for things like placing popups / UI elements on the layer\n  //\n  // TODO: Find proper center position instead of returning first coordinate\n  // SEE: https://github.com/Leaflet/Leaflet/blob/master/src/layer/vector/Polygon.js#L15\n  getCenter() {\n    return this._center;\n  }\n\n  // Return polygon bounds in geographic coordinates\n  //\n  // TODO: Implement getBounds()\n  getBounds() {}\n\n  // Get unique ID for picking interaction\n  _setPickingId() {\n    this._pickingId = this.getPickingId();\n  }\n\n  // Set up and re-emit interaction events\n  _addPickingEvents() {\n    // TODO: Find a way to properly remove this listener on destroy\n    this._world.on('pick-' + this._pickingId, (point2d, point3d, intersects) => {\n      // Re-emit click event from the layer\n      this.emit('click', this, point2d, point3d, intersects);\n    });\n  }\n\n  // Create and store reference to THREE.BufferAttribute data for this layer\n  static SetBufferAttributes(coordinates, options) {\n    return new Promise((resolve) => {\n      var height = 0;\n\n      // Convert height into world units\n      if (options.style.height && options.style.height !== 0) {\n        height = Geo.metresToWorld(options.style.height, options.pointScale);\n      }\n\n      var colour = new THREE.Color();\n      colour.set(options.style.color);\n\n      // Light and dark colours used for poor-mans AO gradient on object sides\n      var light = new THREE.Color(0xffffff);\n      var shadow  = new THREE.Color(0x666666);\n\n      var flat = true;\n\n      var outlineAttributes = [];\n\n      // For each polygon\n      var attributes = coordinates.map(_coordinates => {\n        // Convert coordinates to earcut format\n        var _earcut = PolygonLayer.ToEarcut(_coordinates);\n\n        // Triangulate faces using earcut\n        var faces = PolygonLayer.Triangulate(_earcut.vertices, _earcut.holes, _earcut.dimensions);\n\n        var groupedVertices = [];\n        for (i = 0, il = _earcut.vertices.length; i < il; i += _earcut.dimensions) {\n          groupedVertices.push(_earcut.vertices.slice(i, i + _earcut.dimensions));\n        }\n\n        var extruded = extrudePolygon(groupedVertices, faces, {\n          bottom: 0,\n          top: height\n        });\n\n        var topColor = colour.clone().multiply(light);\n        var bottomColor = colour.clone().multiply(shadow);\n\n        var _vertices = extruded.positions;\n        var _faces = [];\n        var _colours = [];\n        var _tops = [];\n\n        var _colour;\n        extruded.top.forEach((face, fi) => {\n          _colour = [];\n\n          _colour.push([colour.r, colour.g, colour.b]);\n          _colour.push([colour.r, colour.g, colour.b]);\n          _colour.push([colour.r, colour.g, colour.b]);\n\n          _tops.push([true, true, true]);\n\n          _faces.push(face);\n          _colours.push(_colour);\n        });\n\n        if (extruded.sides) {\n          flat = false;\n\n          // Set up colours for every vertex with poor-mans AO on the sides\n          extruded.sides.forEach((face, fi) => {\n            _colour = [];\n\n            // First face is always bottom-bottom-top\n            if (fi % 2 === 0) {\n              _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n              _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n              _colour.push([topColor.r, topColor.g, topColor.b]);\n\n              _tops.push([false, false, true]);\n            // Reverse winding for the second face\n            // top-top-bottom\n            } else {\n              _colour.push([topColor.r, topColor.g, topColor.b]);\n              _colour.push([topColor.r, topColor.g, topColor.b]);\n              _colour.push([bottomColor.r, bottomColor.g, bottomColor.b]);\n\n              _tops.push([true, true, false]);\n            }\n\n            _faces.push(face);\n            _colours.push(_colour);\n          });\n        }\n\n        // Skip bottom as there's no point rendering it\n        // allFaces.push(extruded.faces);\n\n        var polygon = {\n          vertices: _vertices,\n          faces: _faces,\n          colours: _colours,\n          tops: _tops,\n          facesCount: _faces.length\n        };\n\n        if (options.style.outline) {\n          var outlineColour = new THREE.Color();\n          outlineColour.set(options.style.outlineColor || 0x000000);\n\n          outlineAttributes.push(PolygonLayer.Set2DOutline(_coordinates, outlineColour));\n        }\n\n        if (options.interactive && options.pickingId) {\n          // Inject picking ID\n          polygon.pickingId = options.pickingId;\n        }\n\n        // Convert polygon representation to proper attribute arrays\n        return PolygonLayer.ToAttributes(polygon);\n      });\n\n      resolve({\n        attributes: attributes,\n        outlineAttributes: outlineAttributes,\n        flat: flat\n      });\n    });\n  }\n\n  getBufferAttributes() {\n    return this._bufferAttributes;\n  }\n\n  getOutlineBufferAttributes() {\n    return this._outlineBufferAttributes;\n  }\n\n  // Used by external components to clear some memory when the attributes\n  // are no longer required to be stored in this layer\n  //\n  // For example, you would want to clear the attributes here after merging them\n  // using something like the GeoJSONLayer\n  clearBufferAttributes() {\n    this._bufferAttributes = null;\n    this._outlineBufferAttributes = null;\n  }\n\n  // Threshold angle is currently in rads\n  static Set2DOutline(coordinates, colour) {\n    var _vertices = [];\n\n    coordinates.forEach((ring) => {\n      var _ring = ring.map((coordinate) => {\n        return [coordinate.x, 0, coordinate.y];\n      });\n\n      // Add in duplicate vertices for line segments to work\n      var verticeCount = _ring.length;\n      var first = true;\n      while (--verticeCount) {\n        if (first || verticeCount === 0) {\n          first = false;\n          continue;\n        }\n\n        _ring.splice(verticeCount + 1, 0, _ring[verticeCount]);\n      }\n\n      _vertices = _vertices.concat(_ring);\n    });\n\n    _colour = [colour.r, colour.g, colour.b];\n\n    var vertices = new Float32Array(_vertices.length * 3);\n    var colours = new Float32Array(_vertices.length * 3);\n\n    var lastIndex = 0;\n\n    for (var i = 0; i < _vertices.length; i++) {\n      var ax = _vertices[i][0];\n      var ay = _vertices[i][1];\n      var az = _vertices[i][2];\n\n      var c1 = _colour;\n\n      vertices[lastIndex * 3 + 0] = ax;\n      vertices[lastIndex * 3 + 1] = ay;\n      vertices[lastIndex * 3 + 2] = az;\n\n      colours[lastIndex * 3 + 0] = c1[0];\n      colours[lastIndex * 3 + 1] = c1[1];\n      colours[lastIndex * 3 + 2] = c1[2];\n\n      lastIndex++;\n    }\n\n    var attributes = {\n      positions: vertices,\n      colors: colours\n    };\n\n    return attributes;\n  }\n\n  // Used by external components to clear some memory when the coordinates\n  // are no longer required to be stored in this layer\n  //\n  // For example, you would want to clear the coordinates here after this\n  // layer is merged in something like the GeoJSONLayer\n  clearCoordinates() {\n    this._coordinates = null;\n    this._projectedCoordinates = null;\n  }\n\n  static SetMesh(attributes, attributeLengths, flat, style, options, skybox) {\n    var geometry = new THREE.BufferGeometry();\n\n    for (var key in attributes) {\n      geometry.addAttribute(key.slice(0, -1), new THREE.BufferAttribute(attributes[key], attributeLengths[key]));\n    }\n\n    geometry.computeBoundingBox();\n\n    var material;\n    if (options.polygonMaterial && options.polygonMaterial instanceof THREE.Material) {\n      material = options.polygonMaterial;\n    } else if (!skybox) {\n      material = new THREE.MeshPhongMaterial({\n        vertexColors: THREE.VertexColors,\n        side: THREE.BackSide,\n        transparent: style.transparent,\n        opacity: style.opacity,\n        blending: style.blending\n      });\n    } else {\n      material = new THREE.MeshStandardMaterial({\n        vertexColors: THREE.VertexColors,\n        side: THREE.BackSide,\n        transparent: style.transparent,\n        opacity: style.opacity,\n        blending: style.blending\n      });\n      material.roughness = 1;\n      material.metalness = 0.1;\n      material.envMapIntensity = 3;\n      material.envMap = skybox.getRenderTarget();\n    }\n\n    var mesh;\n\n    // Pass mesh through callback, if defined\n    if (typeof options.onPolygonMesh === 'function') {\n      mesh = options.onPolygonMesh(geometry, material);\n    } else {\n      mesh = new THREE.Mesh(geometry, material);\n\n      mesh.castShadow = true;\n      mesh.receiveShadow = true;\n    }\n\n    if (flat) {\n      material.depthWrite = false;\n\n      var renderOrder = (style.renderOrder !== undefined) ? style.renderOrder : 3;\n      mesh.renderOrder = renderOrder;\n    }\n\n    if (options.interactive) {\n      material = new PickingMaterial();\n      material.side = THREE.BackSide;\n\n      var pickingMesh = new THREE.Mesh(geometry, material);\n    }\n\n    return Promise.resolve({\n      mesh: mesh,\n      pickingMesh: pickingMesh\n    });\n  }\n\n  // Convert and project coordinates\n  //\n  // TODO: Calculate bounds\n  _setCoordinates() {\n    this._bounds = [];\n    this._coordinates = this._convertCoordinates(this._coordinates);\n\n    this._projectedBounds = [];\n    this._projectedCoordinates = this._projectCoordinates();\n\n    this._center = this._coordinates[0][0][0];\n  }\n\n  // Recursively convert input coordinates into LatLon objects\n  //\n  // Calculate geographic bounds at the same time\n  //\n  // TODO: Calculate geographic bounds\n  _convertCoordinates(coordinates) {\n    return coordinates.map(_coordinates => {\n      return _coordinates.map(ring => {\n        return ring.map(coordinate => {\n          return LatLon(coordinate[1], coordinate[0]);\n        });\n      });\n    });\n  }\n\n  // Recursively project coordinates into world positions\n  //\n  // Calculate world bounds, offset and pointScale at the same time\n  //\n  // TODO: Calculate world bounds\n  _projectCoordinates() {\n    var point;\n    return this._coordinates.map(_coordinates => {\n      return _coordinates.map(ring => {\n        return ring.map(latlon => {\n          point = this._world.latLonToPoint(latlon);\n\n          // TODO: Is offset ever being used or needed?\n          if (!this._offset) {\n            this._offset = Point(0, 0);\n            this._offset.x = -1 * point.x;\n            this._offset.y = -1 * point.y;\n\n            this._options.pointScale = this._world.pointScale(latlon);\n          }\n\n          return point;\n        });\n      });\n    });\n  }\n\n  // Convert coordinates array to something earcut can understand\n  static ToEarcut(coordinates) {\n    var dim = 2;\n    var result = {vertices: [], holes: [], dimensions: dim};\n    var holeIndex = 0;\n\n    for (var i = 0; i < coordinates.length; i++) {\n      for (var j = 0; j < coordinates[i].length; j++) {\n        // for (var d = 0; d < dim; d++) {\n        result.vertices.push(coordinates[i][j].x);\n        result.vertices.push(coordinates[i][j].y);\n        // }\n      }\n      if (i > 0) {\n        holeIndex += coordinates[i - 1].length;\n        result.holes.push(holeIndex);\n      }\n    }\n\n    return result;\n  }\n\n  // Triangulate earcut-based input using earcut\n  static Triangulate(contour, holes, dim) {\n    // console.time('earcut');\n\n    var faces = earcut(contour, holes, dim);\n    var result = [];\n\n    for (i = 0, il = faces.length; i < il; i += 3) {\n      result.push(faces.slice(i, i + 3));\n    }\n\n    // console.timeEnd('earcut');\n\n    return result;\n  }\n\n  // Transform polygon representation into attribute arrays that can be used by\n  // THREE.BufferGeometry\n  //\n  // TODO: Can this be simplified? It's messy and huge\n  static ToAttributes(polygon) {\n    // Three components per vertex per face (3 x 3 = 9)\n    var positions = new Float32Array(polygon.facesCount * 9);\n    var normals = new Float32Array(polygon.facesCount * 9);\n    var colours = new Float32Array(polygon.facesCount * 9);\n\n    // One component per vertex per face (1 x 3 = 3)\n    var tops = new Float32Array(polygon.facesCount * 3);\n\n    var pickingIds;\n    if (polygon.pickingId) {\n      // One component per vertex per face (1 x 3 = 3)\n      pickingIds = new Float32Array(polygon.facesCount * 3);\n    }\n\n    var pA = new THREE.Vector3();\n    var pB = new THREE.Vector3();\n    var pC = new THREE.Vector3();\n\n    var cb = new THREE.Vector3();\n    var ab = new THREE.Vector3();\n\n    var index;\n\n    var _faces = polygon.faces;\n    var _vertices = polygon.vertices;\n    var _colour = polygon.colours;\n    var _tops = polygon.tops;\n\n    var _pickingId;\n    if (pickingIds) {\n      _pickingId = polygon.pickingId;\n    }\n\n    var lastIndex = 0;\n\n    for (var i = 0; i < _faces.length; i++) {\n      // Array of vertex indexes for the face\n      index = _faces[i][0];\n\n      var ax = _vertices[index][0];\n      var ay = _vertices[index][1];\n      var az = _vertices[index][2];\n\n      var c1 = _colour[i][0];\n      var t1 = _tops[i][0];\n\n      index = _faces[i][1];\n\n      var bx = _vertices[index][0];\n      var by = _vertices[index][1];\n      var bz = _vertices[index][2];\n\n      var c2 = _colour[i][1];\n      var t2 = _tops[i][1];\n\n      index = _faces[i][2];\n\n      var cx = _vertices[index][0];\n      var cy = _vertices[index][1];\n      var cz = _vertices[index][2];\n\n      var c3 = _colour[i][2];\n      var t3 = _tops[i][2];\n\n      // Flat face normals\n      // From: http://threejs.org/examples/webgl_buffergeometry.html\n      pA.set(ax, ay, az);\n      pB.set(bx, by, bz);\n      pC.set(cx, cy, cz);\n\n      cb.subVectors(pC, pB);\n      ab.subVectors(pA, pB);\n      cb.cross(ab);\n\n      cb.normalize();\n\n      var nx = cb.x;\n      var ny = cb.y;\n      var nz = cb.z;\n\n      positions[lastIndex * 9 + 0] = ax;\n      positions[lastIndex * 9 + 1] = ay;\n      positions[lastIndex * 9 + 2] = az;\n\n      normals[lastIndex * 9 + 0] = nx;\n      normals[lastIndex * 9 + 1] = ny;\n      normals[lastIndex * 9 + 2] = nz;\n\n      colours[lastIndex * 9 + 0] = c1[0];\n      colours[lastIndex * 9 + 1] = c1[1];\n      colours[lastIndex * 9 + 2] = c1[2];\n\n      positions[lastIndex * 9 + 3] = bx;\n      positions[lastIndex * 9 + 4] = by;\n      positions[lastIndex * 9 + 5] = bz;\n\n      normals[lastIndex * 9 + 3] = nx;\n      normals[lastIndex * 9 + 4] = ny;\n      normals[lastIndex * 9 + 5] = nz;\n\n      colours[lastIndex * 9 + 3] = c2[0];\n      colours[lastIndex * 9 + 4] = c2[1];\n      colours[lastIndex * 9 + 5] = c2[2];\n\n      positions[lastIndex * 9 + 6] = cx;\n      positions[lastIndex * 9 + 7] = cy;\n      positions[lastIndex * 9 + 8] = cz;\n\n      normals[lastIndex * 9 + 6] = nx;\n      normals[lastIndex * 9 + 7] = ny;\n      normals[lastIndex * 9 + 8] = nz;\n\n      colours[lastIndex * 9 + 6] = c3[0];\n      colours[lastIndex * 9 + 7] = c3[1];\n      colours[lastIndex * 9 + 8] = c3[2];\n\n      tops[lastIndex * 3 + 0] = t1;\n      tops[lastIndex * 3 + 1] = t2;\n      tops[lastIndex * 3 + 2] = t3;\n\n      if (pickingIds) {\n        pickingIds[lastIndex * 3 + 0] = _pickingId;\n        pickingIds[lastIndex * 3 + 1] = _pickingId;\n        pickingIds[lastIndex * 3 + 2] = _pickingId;\n      }\n\n      lastIndex++;\n    }\n\n    var attributes = {\n      positions: positions,\n      normals: normals,\n      colors: colours,\n      tops: tops\n    };\n\n    if (pickingIds) {\n      attributes.pickingIds = pickingIds;\n    }\n\n    return attributes;\n  }\n\n  // Returns true if the polygon is flat (has no height)\n  isFlat() {\n    return this._flat;\n  }\n\n  // Returns true if coordinates refer to a single geometry\n  //\n  // For example, not coordinates for a MultiPolygon GeoJSON feature\n  static isSingle(coordinates) {\n    return !Array.isArray(coordinates[0][0][0]);\n  }\n\n  // TODO: Make sure this is cleaning everything\n  destroy() {\n    if (this._pickingMesh) {\n      // TODO: Properly dispose of picking mesh\n      this._pickingMesh = null;\n    }\n\n    this.clearCoordinates();\n    this.clearBufferAttributes();\n\n    // Run common destruction logic from parent\n    super.destroy();\n  }\n}\n\nexport default PolygonLayer;\n\nvar noNew = function(coordinates, options) {\n  return new PolygonLayer(coordinates, options);\n};\n\nexport {noNew as polygonLayer};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/geometry/PolygonLayer.js\n **/","import THREE from 'three';\nimport PickingShader from './PickingShader';\n\n// FROM: https://github.com/brianxu/GPUPicker/blob/master/GPUPicker.js\n\nvar PickingMaterial = function() {\n  THREE.ShaderMaterial.call(this, {\n    uniforms: {\n      size: {\n        type: 'f',\n        value: 0.01,\n      },\n      scale: {\n        type: 'f',\n        value: 400,\n      }\n    },\n    // attributes: ['position', 'id'],\n    vertexShader: PickingShader.vertexShader,\n    fragmentShader: PickingShader.fragmentShader\n  });\n\n  this.linePadding = 2;\n};\n\nPickingMaterial.prototype = Object.create(THREE.ShaderMaterial.prototype);\n\nPickingMaterial.prototype.constructor = PickingMaterial;\n\nPickingMaterial.prototype.setPointSize = function(size) {\n  this.uniforms.size.value = size;\n};\n\nPickingMaterial.prototype.setPointScale = function(scale) {\n  this.uniforms.scale.value = scale;\n};\n\nexport default PickingMaterial;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/engine/PickingMaterial.js\n **/","// FROM: https://github.com/brianxu/GPUPicker/blob/master/GPUPicker.js\n\nvar PickingShader = {\n  vertexShader: [\n\t\t'attribute float pickingId;',\n\t\t// '',\n\t\t// 'uniform float size;',\n\t\t// 'uniform float scale;',\n\t\t'',\n\t\t'varying vec4 worldId;',\n\t\t'',\n\t\t'void main() {',\n\t\t'  vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',\n\t\t// '  gl_PointSize = size * ( scale / length( mvPosition.xyz ) );',\n\t\t'  vec3 a = fract(vec3(1.0/255.0, 1.0/(255.0*255.0), 1.0/(255.0*255.0*255.0)) * pickingId);',\n\t\t'  a -= a.xxy * vec3(0.0, 1.0/255.0, 1.0/255.0);',\n\t\t'  worldId = vec4(a,1);',\n\t\t'  gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',\n\t\t'}'\n\t].join('\\n'),\n\n  fragmentShader: [\n\t\t'#ifdef GL_ES\\n',\n\t\t'precision highp float;\\n',\n\t\t'#endif\\n',\n\t\t'',\n\t\t'varying vec4 worldId;',\n\t\t'',\n\t\t'void main() {',\n\t\t'  gl_FragColor = worldId;',\n\t\t'}'\n\t].join('\\n')\n};\n\nexport default PickingShader;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/engine/PickingShader.js\n **/","// TODO: Move duplicated logic between geometry layrs into GeometryLayer\n\n// TODO: Look at ways to drop unneeded references to array buffers, etc to\n// reduce memory footprint\n\n// TODO: Provide alternative output using tubes and splines / curves\n\n// TODO: Support dynamic updating / hiding / animation of geometry\n//\n// This could be pretty hard as it's all packed away within BufferGeometry and\n// may even be merged by another layer (eg. GeoJSONLayer)\n//\n// How much control should this layer support? Perhaps a different or custom\n// layer would be better suited for animation, for example.\n\n// TODO: Allow _setBufferAttributes to use a custom function passed in to\n// generate a custom mesh\n\nimport Layer from '../Layer';\nimport extend from 'lodash.assign';\nimport THREE from 'three';\nimport Geo from '../../geo/Geo';\nimport {latLon as LatLon} from '../../geo/LatLon';\nimport {point as Point} from '../../geo/Point';\nimport PickingMaterial from '../../engine/PickingMaterial';\nimport Buffer from '../../util/Buffer';\n\nclass PolylineLayer extends Layer {\n  constructor(coordinates, options) {\n    var defaults = {\n      output: true,\n      interactive: false,\n      // Custom material override\n      //\n      // TODO: Should this be in the style object?\n      polylineMaterial: null,\n      onPolylineMesh: null,\n      onBufferAttributes: null,\n      // This default style is separate to Util.GeoJSON.defaultStyle\n      style: {\n        lineOpacity: 1,\n        lineTransparent: false,\n        lineColor: '#ffffff',\n        lineWidth: 1,\n        lineBlending: THREE.NormalBlending\n      }\n    };\n\n    var _options = extend({}, defaults, options);\n\n    super(_options);\n\n    // Return coordinates as array of lines so it's easy to support\n    // MultiLineString features (a single line would be a MultiLineString with a\n    // single line in the array)\n    this._coordinates = (PolylineLayer.isSingle(coordinates)) ? [coordinates] : coordinates;\n\n    // Polyline features are always flat (for now at least)\n    this._flat = true;\n  }\n\n  _onAdd(world) {\n    return new Promise((resolve, reject) => {\n      this._setCoordinates();\n\n      if (this._options.interactive) {\n        // Only add to picking mesh if this layer is controlling output\n        //\n        // Otherwise, assume another component will eventually add a mesh to\n        // the picking scene\n        if (this.isOutput()) {\n          this._pickingMesh = new THREE.Object3D();\n          this.addToPicking(this._pickingMesh);\n        }\n\n        this._setPickingId();\n        this._addPickingEvents();\n      }\n\n      // Store geometry representation as instances of THREE.BufferAttribute\n      PolylineLayer.SetBufferAttributes(this._projectedCoordinates, this._options).then((result) => {\n        this._bufferAttributes = Buffer.mergeAttributes(result.attributes);\n        this._flat = result.flat;\n\n        var attributeLengths = {\n          positions: 3,\n          colors: 3\n        };\n\n        if (this._options.interactive) {\n          attributeLengths.pickingIds = 1;\n        }\n\n        if (this.isOutput()) {\n          var style = this._options.style;\n\n          // Set mesh if not merging elsewhere\n          PolylineLayer.SetMesh(this._bufferAttributes, attributeLengths, this._flat, style, this._options).then((result) => {\n            // Output mesh\n            this.add(result.mesh);\n\n            if (result.pickingMesh) {\n              this._pickingMesh.add(result.pickingMesh);\n            }\n          });\n        }\n\n        result.attributes = null;\n        result = null;\n\n        resolve(this);\n      });\n    });\n  }\n\n  // Return center of polyline as a LatLon\n  //\n  // This is used for things like placing popups / UI elements on the layer\n  //\n  // TODO: Find proper center position instead of returning first coordinate\n  // SEE: https://github.com/Leaflet/Leaflet/blob/master/src/layer/vector/Polyline.js#L59\n  getCenter() {\n    return this._center;\n  }\n\n  // Return line bounds in geographic coordinates\n  //\n  // TODO: Implement getBounds()\n  getBounds() {}\n\n  // Get unique ID for picking interaction\n  _setPickingId() {\n    this._pickingId = this.getPickingId();\n  }\n\n  // Set up and re-emit interaction events\n  _addPickingEvents() {\n    // TODO: Find a way to properly remove this listener on destroy\n    this._world.on('pick-' + this._pickingId, (point2d, point3d, intersects) => {\n      // Re-emit click event from the layer\n      this.emit('click', this, point2d, point3d, intersects);\n    });\n  }\n\n  static SetBufferAttributes(coordinates, options) {\n    return new Promise((resolve) => {\n      var height = 0;\n\n      // Convert height into world units\n      if (options.style.lineHeight) {\n        height = Geo.metresToWorld(options.style.lineHeight, options.pointScale);\n      }\n\n      var colour = new THREE.Color();\n      colour.set(options.style.lineColor);\n\n      var flat = true;\n\n      // For each line\n      var attributes = coordinates.map(_projectedCoordinates => {\n        var _vertices = [];\n        var _colours = [];\n\n        // Connect coordinate with the next to make a pair\n        //\n        // LineSegments requires pairs of vertices so repeat the last point if\n        // there's an odd number of vertices\n        var nextCoord;\n        _projectedCoordinates.forEach((coordinate, index) => {\n          _colours.push([colour.r, colour.g, colour.b]);\n          _vertices.push([coordinate.x, height, coordinate.y]);\n\n          nextCoord = (_projectedCoordinates[index + 1]) ? _projectedCoordinates[index + 1] : coordinate;\n\n          _colours.push([colour.r, colour.g, colour.b]);\n          _vertices.push([nextCoord.x, height, nextCoord.y]);\n        });\n\n        var line = {\n          vertices: _vertices,\n          colours: _colours,\n          verticesCount: _vertices.length\n        };\n\n        if (options.interactive && options.pickingId) {\n          // Inject picking ID\n          line.pickingId = options.pickingId;\n        }\n\n        // Convert line representation to proper attribute arrays\n        return PolylineLayer.ToAttributes(line);\n      });\n\n      resolve({\n        attributes: attributes,\n        flat: flat\n      });\n    });\n  }\n\n  getBufferAttributes() {\n    return this._bufferAttributes;\n  }\n\n  // Used by external components to clear some memory when the attributes\n  // are no longer required to be stored in this layer\n  //\n  // For example, you would want to clear the attributes here after merging them\n  // using something like the GeoJSONLayer\n  clearBufferAttributes() {\n    this._bufferAttributes = null;\n  }\n\n  // Used by external components to clear some memory when the coordinates\n  // are no longer required to be stored in this layer\n  //\n  // For example, you would want to clear the coordinates here after this\n  // layer is merged in something like the GeoJSONLayer\n  clearCoordinates() {\n    this._coordinates = null;\n    this._projectedCoordinates = null;\n  }\n\n  static SetMesh(attributes, attributeLengths, flat, style, options) {\n    var geometry = new THREE.BufferGeometry();\n\n    for (var key in attributes) {\n      geometry.addAttribute(key.slice(0, -1), new THREE.BufferAttribute(attributes[key], attributeLengths[key]));\n    }\n\n    geometry.computeBoundingBox();\n\n    var material;\n    if (options.polylineMaterial && options.polylineMaterial instanceof THREE.Material) {\n      material = options.polylineMaterial;\n    } else {\n      material = new THREE.LineBasicMaterial({\n        vertexColors: THREE.VertexColors,\n        linewidth: style.lineWidth,\n        transparent: style.lineTransparent,\n        opacity: style.lineOpacity,\n        blending: style.lineBlending\n      });\n    }\n\n    var mesh;\n\n    // Pass mesh through callback, if defined\n    if (typeof options.onPolylineMesh === 'function') {\n      mesh = options.onPolylineMesh(geometry, material);\n    } else {\n      mesh = new THREE.LineSegments(geometry, material);\n\n      if (style.lineRenderOrder !== undefined) {\n        material.depthWrite = false;\n        mesh.renderOrder = style.lineRenderOrder;\n      }\n\n      mesh.castShadow = true;\n      // mesh.receiveShadow = true;\n    }\n\n    if (options.interactive) {\n      material = new PickingMaterial();\n      // material.side = THREE.BackSide;\n\n      // Make the line wider / easier to pick\n      material.linewidth = style.lineWidth + material.linePadding;\n\n      var pickingMesh = new THREE.LineSegments(geometry, material);\n    }\n\n    return Promise.resolve({\n      mesh: mesh,\n      pickingMesh: pickingMesh\n    });\n  }\n\n  // Convert and project coordinates\n  //\n  // TODO: Calculate bounds\n  _setCoordinates() {\n    this._bounds = [];\n    this._coordinates = this._convertCoordinates(this._coordinates);\n\n    this._projectedBounds = [];\n    this._projectedCoordinates = this._projectCoordinates();\n\n    this._center = this._coordinates[0][0];\n  }\n\n  // Recursively convert input coordinates into LatLon objects\n  //\n  // Calculate geographic bounds at the same time\n  //\n  // TODO: Calculate geographic bounds\n  _convertCoordinates(coordinates) {\n    return coordinates.map(_coordinates => {\n      return _coordinates.map(coordinate => {\n        return LatLon(coordinate[1], coordinate[0]);\n      });\n    });\n  }\n\n  // Recursively project coordinates into world positions\n  //\n  // Calculate world bounds, offset and pointScale at the same time\n  //\n  // TODO: Calculate world bounds\n  _projectCoordinates() {\n    var point;\n    return this._coordinates.map(_coordinates => {\n      return _coordinates.map(latlon => {\n        point = this._world.latLonToPoint(latlon);\n\n        // TODO: Is offset ever being used or needed?\n        if (!this._offset) {\n          this._offset = Point(0, 0);\n          this._offset.x = -1 * point.x;\n          this._offset.y = -1 * point.y;\n\n          this._options.pointScale = this._world.pointScale(latlon);\n        }\n\n        return point;\n      });\n    });\n  }\n\n  static ToAttributes(line) {\n    // Three components per vertex\n    var vertices = new Float32Array(line.verticesCount * 3);\n    var colours = new Float32Array(line.verticesCount * 3);\n\n    var pickingIds;\n    if (line.pickingId) {\n      // One component per vertex\n      pickingIds = new Float32Array(line.verticesCount);\n    }\n\n    var _vertices = line.vertices;\n    var _colour = line.colours;\n\n    var _pickingId;\n    if (pickingIds) {\n      _pickingId = line.pickingId;\n    }\n\n    var lastIndex = 0;\n\n    for (var i = 0; i < _vertices.length; i++) {\n      var ax = _vertices[i][0];\n      var ay = _vertices[i][1];\n      var az = _vertices[i][2];\n\n      var c1 = _colour[i];\n\n      vertices[lastIndex * 3 + 0] = ax;\n      vertices[lastIndex * 3 + 1] = ay;\n      vertices[lastIndex * 3 + 2] = az;\n\n      colours[lastIndex * 3 + 0] = c1[0];\n      colours[lastIndex * 3 + 1] = c1[1];\n      colours[lastIndex * 3 + 2] = c1[2];\n\n      if (pickingIds) {\n        pickingIds[lastIndex] = _pickingId;\n      }\n\n      lastIndex++;\n    }\n\n    var attributes = {\n      positions: vertices,\n      colors: colours\n    };\n\n    if (pickingIds) {\n      attributes.pickingIds = pickingIds;\n    }\n\n    return attributes;\n  }\n\n  // Returns true if the line is flat (has no height)\n  isFlat() {\n    return this._flat;\n  }\n\n  // Returns true if coordinates refer to a single geometry\n  //\n  // For example, not coordinates for a MultiLineString GeoJSON feature\n  static isSingle(coordinates) {\n    return !Array.isArray(coordinates[0][0]);\n  }\n\n  destroy() {\n    if (this._pickingMesh) {\n      // TODO: Properly dispose of picking mesh\n      this._pickingMesh = null;\n    }\n\n    this.clearCoordinates();\n    this.clearBufferAttributes();\n\n    // Run common destruction logic from parent\n    super.destroy();\n  }\n}\n\nexport default PolylineLayer;\n\nvar noNew = function(coordinates, options) {\n  return new PolylineLayer(coordinates, options);\n};\n\nexport {noNew as polylineLayer};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/geometry/PolylineLayer.js\n **/","// TODO: Move duplicated logic between geometry layrs into GeometryLayer\n\n// TODO: Look at ways to drop unneeded references to array buffers, etc to\n// reduce memory footprint\n\n// TODO: Point features may be using custom models / meshes and so an approach\n// needs to be found to allow these to be brokwn down into buffer attributes for\n// merging\n//\n// Can probably use fromGeometry() or setFromObject() from THREE.BufferGeometry\n// and pull out the attributes\n\n// TODO: Support sprite objects using textures\n\n// TODO: Provide option to billboard geometry so it always faces the camera\n\n// TODO: Support dynamic updating / hiding / animation of geometry\n//\n// This could be pretty hard as it's all packed away within BufferGeometry and\n// may even be merged by another layer (eg. GeoJSONLayer)\n//\n// How much control should this layer support? Perhaps a different or custom\n// layer would be better suited for animation, for example.\n\nimport Layer from '../Layer';\nimport extend from 'lodash.assign';\nimport THREE from 'three';\nimport Geo from '../../geo/Geo';\nimport {latLon as LatLon} from '../../geo/LatLon';\nimport {point as Point} from '../../geo/Point';\nimport PickingMaterial from '../../engine/PickingMaterial';\nimport Buffer from '../../util/Buffer';\nimport PolygonLayer from './PolygonLayer';\n\nclass PointLayer extends Layer {\n  constructor(coordinates, options) {\n    var defaults = {\n      output: true,\n      interactive: false,\n      // THREE.Geometry or THREE.BufferGeometry to use for point output\n      pointGeometry: null,\n      // Custom material override\n      //\n      // TODO: Should this be in the style object?\n      pointMaterial: null,\n      onPointMesh: null,\n      // This default style is separate to Util.GeoJSON.defaultStyle\n      style: {\n        pointColor: '#ff0000'\n      }\n    };\n\n    var _options = extend({}, defaults, options);\n\n    super(_options);\n\n    // Return coordinates as array of points so it's easy to support\n    // MultiPoint features (a single point would be a MultiPoint with a\n    // single point in the array)\n    this._coordinates = (PointLayer.isSingle(coordinates)) ? [coordinates] : coordinates;\n\n    this._flat = false;\n  }\n\n  _onAdd(world) {\n    return new Promise((resolve, reject) => {\n      this._setCoordinates();\n\n      if (this._options.interactive) {\n        // Only add to picking mesh if this layer is controlling output\n        //\n        // Otherwise, assume another component will eventually add a mesh to\n        // the picking scene\n        if (this.isOutput()) {\n          this._pickingMesh = new THREE.Object3D();\n          this.addToPicking(this._pickingMesh);\n        }\n\n        this._setPickingId();\n        this._addPickingEvents();\n      }\n\n      // Store geometry representation as instances of THREE.BufferAttribute\n      PointLayer.SetBufferAttributes(this._projectedCoordinates, this._options).then((result) => {\n        this._bufferAttributes = Buffer.mergeAttributes(result.attributes);\n        this._flat = result.flat;\n\n        var attributeLengths = {\n          positions: 3,\n          normals: 3,\n          colors: 3\n        };\n\n        if (this._options.interactive) {\n          attributeLengths.pickingIds = 1;\n        }\n\n        if (this.isOutput()) {\n          var style = this._options.style;\n\n          // Set mesh if not merging elsewhere\n          // TODO: Dedupe with PolygonLayer as they are identical\n          PointLayer.SetMesh(this._bufferAttributes, attributeLengths, this._flat, style, this._options, this._world._environment._skybox).then((result) => {\n            // Output mesh\n            this.add(result.mesh);\n\n            if (result.pickingMesh) {\n              this._pickingMesh.add(result.pickingMesh);\n            }\n          });\n        }\n\n        result.attributes = null;\n        result = null;\n\n        resolve(this);\n      }).catch(reject);\n    });\n  }\n\n  // Return center of point as a LatLon\n  //\n  // This is used for things like placing popups / UI elements on the layer\n  getCenter() {\n    return this._center;\n  }\n\n  // Return point bounds in geographic coordinates\n  //\n  // While not useful for single points, it could be useful for MultiPoint\n  //\n  // TODO: Implement getBounds()\n  getBounds() {}\n\n  // Get unique ID for picking interaction\n  _setPickingId() {\n    this._pickingId = this.getPickingId();\n  }\n\n  // Set up and re-emit interaction events\n  _addPickingEvents() {\n    // TODO: Find a way to properly remove this listener on destroy\n    this._world.on('pick-' + this._pickingId, (point2d, point3d, intersects) => {\n      // Re-emit click event from the layer\n      this.emit('click', this, point2d, point3d, intersects);\n    });\n  }\n\n  static SetBufferAttributes(coordinates, options) {\n    return new Promise((resolve) => {\n      var height = 0;\n\n      // Convert height into world units\n      if (options.style.pointHeight) {\n        height = Geo.metresToWorld(options.style.pointHeight, options.pointScale);\n      }\n\n      var colour = new THREE.Color();\n      colour.set(options.style.pointColor);\n\n      // Use default geometry if none has been provided or the provided geometry\n      // isn't valid\n      if (!options.pointGeometry || (!options.pointGeometry instanceof THREE.Geometry || !options.pointGeometry instanceof THREE.BufferGeometry)) {\n        // Debug geometry for points is a thin bar\n        //\n        // TODO: Allow point geometry to be customised / overridden\n        var geometryWidth = Geo.metresToWorld(25, options.pointScale);\n        var geometryHeight = Geo.metresToWorld(200, options.pointScale);\n        var _geometry = new THREE.BoxGeometry(geometryWidth, geometryHeight, geometryWidth);\n\n        // Shift geometry up so it sits on the ground\n        _geometry.translate(0, geometryHeight * 0.5, 0);\n\n        // Pull attributes out of debug geometry\n        geometry = new THREE.BufferGeometry().fromGeometry(_geometry);\n      } else {\n        if (options.geometry instanceof THREE.BufferGeometry) {\n          geometry = options.pointGeometry;\n        } else {\n          geometry = new THREE.BufferGeometry().fromGeometry(options.pointGeometry);\n        }\n      }\n\n      var attributes = coordinates.map((coordinate) => {\n        var _vertices = [];\n        var _normals = [];\n        var _colours = [];\n\n        var _geometry = geometry.clone();\n        _geometry.translate(coordinate.x, height, coordinate.y);\n\n        var _vertices = _geometry.attributes.position.clone().array;\n        var _normals = _geometry.attributes.normal.clone().array;\n        var _colours = _geometry.attributes.color.clone().array;\n\n        for (var i = 0; i < _colours.length; i += 3) {\n          _colours[i] = colour.r;\n          _colours[i + 1] = colour.g;\n          _colours[i + 2] = colour.b;\n        }\n\n        var _point = {\n          positions: _vertices,\n          normals: _normals,\n          colors: _colours\n        };\n\n        if (options.interactive && options.pickingId) {\n          // Inject picking ID\n          _point.pickingId = options.pickingId;\n        }\n\n        return _point;\n      });\n\n      resolve({\n        attributes: attributes,\n        flat: false\n      });\n    });\n  }\n\n  getBufferAttributes() {\n    return this._bufferAttributes;\n  }\n\n  // Used by external components to clear some memory when the attributes\n  // are no longer required to be stored in this layer\n  //\n  // For example, you would want to clear the attributes here after merging them\n  // using something like the GeoJSONLayer\n  clearBufferAttributes() {\n    this._bufferAttributes = null;\n  }\n\n  // Used by external components to clear some memory when the coordinates\n  // are no longer required to be stored in this layer\n  //\n  // For example, you would want to clear the coordinates here after this\n  // layer is merged in something like the GeoJSONLayer\n  clearCoordinates() {\n    this._coordinates = null;\n    this._projectedCoordinates = null;\n  }\n\n  static SetMesh(attributes, attributeLengths, flat, style, options, skybox) {\n    var geometry = new THREE.BufferGeometry();\n\n    for (var key in attributes) {\n      geometry.addAttribute(key.slice(0, -1), new THREE.BufferAttribute(attributes[key], attributeLengths[key]));\n    }\n\n    geometry.computeBoundingBox();\n\n    var material;\n    if (options.pointMaterial && options.pointMaterial instanceof THREE.Material) {\n      material = options.pointMaterial;\n    } else if (!skybox) {\n      material = new THREE.MeshPhongMaterial({\n        vertexColors: THREE.VertexColors,\n        // side: THREE.BackSide,\n        transparent: style.transparent,\n        opacity: style.opacity,\n        blending: style.blending\n      });\n    } else {\n      material = new THREE.MeshStandardMaterial({\n        vertexColors: THREE.VertexColors,\n        // side: THREE.BackSide,\n        transparent: style.transparent,\n        opacity: style.opacity,\n        blending: style.blending\n      });\n      material.roughness = 1;\n      material.metalness = 0.1;\n      material.envMapIntensity = 3;\n      material.envMap = skybox.getRenderTarget();\n    }\n\n    var mesh;\n\n    // Pass mesh through callback, if defined\n    if (typeof options.onPolygonMesh === 'function') {\n      mesh = options.onPolygonMesh(geometry, material);\n    } else {\n      mesh = new THREE.Mesh(geometry, material);\n\n      mesh.castShadow = true;\n      mesh.receiveShadow = true;\n    }\n\n    if (flat) {\n      material.depthWrite = false;\n      mesh.renderOrder = 4;\n    }\n\n    if (options.interactive) {\n      material = new PickingMaterial();\n      material.side = THREE.BackSide;\n\n      var pickingMesh = new THREE.Mesh(geometry, material);\n    }\n\n    return Promise.resolve({\n      mesh: mesh,\n      pickingMesh: pickingMesh\n    });\n  }\n\n  // Convert and project coordinates\n  //\n  // TODO: Calculate bounds\n  _setCoordinates() {\n    this._bounds = [];\n    this._coordinates = this._convertCoordinates(this._coordinates);\n\n    this._projectedBounds = [];\n    this._projectedCoordinates = this._projectCoordinates();\n\n    this._center = this._coordinates;\n  }\n\n  // Recursively convert input coordinates into LatLon objects\n  //\n  // Calculate geographic bounds at the same time\n  //\n  // TODO: Calculate geographic bounds\n  _convertCoordinates(coordinates) {\n    return coordinates.map(coordinate => {\n      return LatLon(coordinate[1], coordinate[0]);\n    });\n  }\n\n  // Recursively project coordinates into world positions\n  //\n  // Calculate world bounds, offset and pointScale at the same time\n  //\n  // TODO: Calculate world bounds\n  _projectCoordinates() {\n    var _point;\n    return this._coordinates.map(latlon => {\n      _point = this._world.latLonToPoint(latlon);\n\n      // TODO: Is offset ever being used or needed?\n      if (!this._offset) {\n        this._offset = Point(0, 0);\n        this._offset.x = -1 * _point.x;\n        this._offset.y = -1 * _point.y;\n\n        this._options.pointScale = this._world.pointScale(latlon);\n      }\n\n      return _point;\n    });\n  }\n\n  // Returns true if the line is flat (has no height)\n  isFlat() {\n    return this._flat;\n  }\n\n  // Returns true if coordinates refer to a single geometry\n  //\n  // For example, not coordinates for a MultiPoint GeoJSON feature\n  static isSingle(coordinates) {\n    return !Array.isArray(coordinates[0]);\n  }\n\n  destroy() {\n    if (this._pickingMesh) {\n      // TODO: Properly dispose of picking mesh\n      this._pickingMesh = null;\n    }\n\n    this.clearCoordinates();\n    this.clearBufferAttributes();\n\n    // Run common destruction logic from parent\n    super.destroy();\n  }\n}\n\nexport default PointLayer;\n\nvar noNew = function(coordinates, options) {\n  return new PointLayer(coordinates, options);\n};\n\nexport {noNew as pointLayer};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/geometry/PointLayer.js\n **/","// TODO: A lot of these utils don't need to be in separate, tiny files\n\nimport wrapNum from './wrapNum';\nimport extrudePolygon from './extrudePolygon';\nimport GeoJSON from './GeoJSON';\nimport Buffer from './Buffer';\nimport Worker from './Worker';\nimport Stringify from './Stringify';\n\nconst Util = {};\n\nUtil.wrapNum = wrapNum;\nUtil.extrudePolygon = extrudePolygon;\nUtil.GeoJSON = GeoJSON;\nUtil.Buffer = Buffer;\nUtil.Worker = Worker;\nUtil.Stringify = Stringify;\n\nexport default Util;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/index.js\n **/","/*\n * Wrap the given number to lie within a certain range (eg. longitude)\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/core/Util.js\n */\n\nvar wrapNum = function(x, range, includeMax) {\n  var max = range[1];\n  var min = range[0];\n  var d = max - min;\n  return x === max && includeMax ? x : ((x - min) % d + d) % d + min;\n};\n\nexport default wrapNum;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/wrapNum.js\n **/"],"sourceRoot":"/source/"}