mirror
/
vizicities
kopia lustrzana https://github.com/robhawkes/vizicities
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
vizicities/dist/vizicities.min.js.map

1 wiersz
860 KiB
Plaintext
Czysty Wina Historia

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","vizicities.min.js","webpack:/webpack/bootstrap bd85d32bfc37ee7d2eb7","webpack:///src/vizicities.js","webpack:///src/World.js","webpack:///~/eventemitter3/index.js","webpack:///~/lodash.assign/index.js","webpack:///~/lodash.keys/index.js","webpack:///~/lodash.rest/index.js","webpack:///src/geo/CRS/index.js","webpack:///src/geo/CRS/CRS.EPSG3857.js","webpack:///src/geo/CRS/CRS.Earth.js","webpack:///src/geo/CRS/CRS.js","webpack:///src/geo/LatLon.js","webpack:///src/geo/Point.js","webpack:///src/util/wrapNum.js","webpack:///src/geo/projection/Projection.SphericalMercator.js","webpack:///src/util/Transformation.js","webpack:///src/geo/CRS/CRS.EPSG3395.js","webpack:///src/geo/projection/Projection.Mercator.js","webpack:///src/geo/CRS/CRS.EPSG4326.js","webpack:///src/geo/projection/Projection.LatLon.js","webpack:///src/geo/CRS/CRS.Simple.js","webpack:///src/geo/CRS/CRS.Proj4.js","webpack:///src/geo/projection/Projection.Proj4.js","webpack:/external \"proj4\"","webpack:///src/engine/Engine.js","webpack:/external \"THREE\"","webpack:///src/engine/Scene.js","webpack:///src/engine/Renderer.js","webpack:///src/engine/Camera.js","webpack:///src/controls/index.js","webpack:///src/controls/Controls.Orbit.js","webpack:///src/vendor/OrbitControls.js","webpack:///src/layer/environment/EnvironmentLayer.js","webpack:///src/layer/Layer.js","webpack:///src/layer/environment/Skybox.js","webpack:///src/layer/environment/Sky.js","webpack:///~/lodash.throttle/index.js","webpack:///~/lodash.throttle/~/lodash.debounce/index.js","webpack:///src/layer/tile/ImageTileLayer.js","webpack:///src/layer/tile/TileLayer.js","webpack:///src/layer/tile/TileCache.js","webpack:///~/lru-cache/lib/lru-cache.js","webpack:///~/pseudomap/map.js","webpack:///~/process/browser.js","webpack:///~/pseudomap/pseudomap.js","webpack:///~/util/util.js","webpack:///~/util/support/isBufferBrowser.js","webpack:///~/inherits/inherits_browser.js","webpack:///~/yallist/yallist.js","webpack:///src/layer/tile/ImageTile.js","webpack:///src/layer/tile/Tile.js","webpack:///src/vendor/BoxHelper.js","webpack:///src/layer/tile/ImageTileLayerBaseMaterial.js","webpack:///src/layer/tile/TopoJSONTileLayer.js","webpack:///src/layer/tile/TopoJSONTile.js","webpack:///~/reqwest/reqwest.js","webpack:///~/topojson/build/topojson.js","webpack:///~/earcut/src/earcut.js","webpack:///src/util/extrudePolygon.js","webpack:///~/polygon-offset/src/offset.js","webpack:///~/polygon-offset/~/greiner-hormann/src/greiner-hormann.js","webpack:///~/polygon-offset/~/greiner-hormann/src/clip.js","webpack:///~/polygon-offset/~/greiner-hormann/src/polygon.js","webpack:///~/polygon-offset/~/greiner-hormann/src/vertex.js","webpack:///~/polygon-offset/~/greiner-hormann/src/intersection.js","webpack:///~/polygon-offset/src/edge.js","webpack:///~/polygon-offset/src/intersection.js"],"names":["root","factory","exports","module","require","define","amd","this","__WEBPACK_EXTERNAL_MODULE_22__","__WEBPACK_EXTERNAL_MODULE_24__","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","_interopRequireDefault","obj","__esModule","default","Object","defineProperty","value","_World","_World2","_controlsIndex","_controlsIndex2","_layerEnvironmentEnvironmentLayer","_layerEnvironmentEnvironmentLayer2","_layerTileImageTileLayer","_layerTileImageTileLayer2","_layerTileTopoJSONTileLayer","_layerTileTopoJSONTileLayer2","_geoPoint","_geoPoint2","_geoLatLon","_geoLatLon2","VIZI","version","World","Controls","EnvironmentLayer","ImageTileLayer","TopoJSONTileLayer","Point","LatLon","_classCallCheck","instance","Constructor","TypeError","_inherits","subClass","superClass","prototype","create","constructor","enumerable","writable","configurable","setPrototypeOf","__proto__","_createClass","defineProperties","target","props","i","length","descriptor","key","protoProps","staticProps","_get","_x","_x2","_x3","_again","object","property","receiver","Function","desc","getOwnPropertyDescriptor","undefined","getter","get","parent","getPrototypeOf","_eventemitter3","_eventemitter32","_lodashAssign","_lodashAssign2","_geoCRSIndex","_geoCRSIndex2","_engineEngine","_engineEngine2","_EventEmitter","domId","options","defaults","crs","EPSG3857","skybox","_layers","_controls","_initContainer","_initEngine","_initEnvironment","_initEvents","_update","_container","document","getElementById","_engine","_environment","addTo","on","_onControlsMoveEnd","point","_point","x","z","_resetView","pointToLatLon","latlon","emit","_moveStart","_move","_moveEnd","_lastPosition","delta","clock","getDelta","window","requestAnimationFrame","bind","forEach","controls","update","_originLatlon","_originPoint","project","latLonToPoint","projectedPoint","_subtract","add","unproject","accurate","pointScale","metres","zoom","metresToWorld","worldUnits","worldToMetres","_camera","layer","_addToWorld","push","_scene","_layer","layerIndex","indexOf","splice","remove","destroy","EE","fn","context","once","EventEmitter","prefix","_events","listeners","event","exists","evt","available","l","ee","Array","a1","a2","a3","a4","a5","args","len","arguments","removeListener","apply","j","listener","events","removeAllListeners","off","addListener","setMaxListeners","prefixed","isIndex","reIsUint","test","MAX_SAFE_INTEGER","assignValue","objValue","eq","objectProto","hasOwnProperty","baseProperty","copyObject","source","copyObjectWith","customizer","index","newValue","createAssigner","assigner","rest","sources","guard","isIterateeCall","isObject","type","isArrayLike","other","isFunction","isLength","getLength","tag","objectToString","funcTag","genTag","keys","toString","assign","baseTimes","n","iteratee","result","baseHas","baseKeys","nativeKeys","indexKeys","isArray","isString","isArguments","String","isPrototype","Ctor","proto","isArrayLikeObject","propertyIsEnumerable","argsTag","isObjectLike","stringTag","isProto","indexes","skipIndexes","func","thisArg","start","FUNC_ERROR_TEXT","nativeMax","toInteger","array","otherArgs","toNumber","INFINITY","sign","MAX_INTEGER","remainder","valueOf","replace","reTrim","isBinary","reIsBinary","reIsOctal","freeParseInt","slice","reIsBadHex","NAN","parseInt","Math","max","_CRSEPSG3857","_CRSEPSG38572","_CRSEPSG3395","_CRSEPSG33952","_CRSEPSG4326","_CRSEPSG43262","_CRSSimple","_CRSSimple2","_CRSProj4","_CRSProj42","CRS","EPSG900913","EPSG3395","EPSG4326","Simple","Proj4","_CRSEarth","_CRSEarth2","_projectionProjectionSphericalMercator","_projectionProjectionSphericalMercator2","_utilTransformation","_utilTransformation2","_EPSG3857","code","projection","transformScale","PI","R","transformation","scale","_CRS","_CRS2","_LatLon","Earth","wrapLon","distance","latlon1","latlon2","lat1","lat2","a","rad","lat","lon1","lon","lon2","deltaLat","deltaLon","halfDeltaLat","halfDeltaLon","sin","cos","atan2","sqrt","acos","min","metresToProjected","projectedToMetres","projectedUnits","projectedMetres","scaledMetres","realMetres","_LatLon2","_Point","_Point2","_utilWrapNum","_utilWrapNum2","scaleFactor","_transform","untransformedPoint","untransform","pow","log","LN2","getProjectedBounds","infinite","b","bounds","s","transform","wrapLatLon","wrapLat","alt","isNaN","Error","lng","y","round","clone","_add","wrapNum","range","includeMax","d","SphericalMercator","MAX_LATITUDE","ECC","ECC2","atan","exp","k","sinLat","sinLat2","cosLat","v","h","Transformation","_a","_b","_c","_d","_projectionProjectionMercator","_projectionProjectionMercator2","_EPSG3395","Mercator","R_MINOR","r","tmp","e","con","ts","tan","phi","dphi","abs","_projectionProjectionLatLon","_projectionProjectionLatLon2","_EPSG4326","ProjectionLatLon","m1","m2","m3","m4","p1","p2","p3","latlen","lonlen","_Simple","dx","dy","_projectionProjectionProj4","_projectionProjectionProj42","_Proj4","def","diffX","diffY","halfX","halfY","scaleX","scaleY","offsetX","offsetY","_proj4","_proj42","proj","forward","inverse","bottomLeft","topRight","_three","_three2","_Scene","_Scene2","_Renderer","_Renderer2","_Camera","_Camera2","Engine","container","console","_renderer","Clock","_frustum","Frustum","render","scene","Scene","renderer","WebGLRenderer","antialias","setClearColor","gammaInput","gammaOutput","shadowMap","enabled","cullFace","CullFaceBack","appendChild","domElement","updateSize","setSize","clientWidth","clientHeight","addEventListener","camera","PerspectiveCamera","position","aspect","updateProjectionMatrix","_ControlsOrbit","_ControlsOrbit2","Orbit","_vendorOrbitControls","_vendorOrbitControls2","_this","_world","animate","pointDelta","metresDelta","angle","angleDelta","noZoom","world","addControls","maxPolarAngle","OrbitControls","getAutoRotationAngle","scope","autoRotateSpeed","getZoomScale","zoomSpeed","rotateLeft","thetaDelta","rotateUp","phiDelta","dollyIn","dollyScale","OrthographicCamera","minZoom","maxZoom","zoomChanged","warn","enableZoom","dollyOut","handleMouseDownRotate","rotateStart","set","clientX","clientY","handleMouseDownDolly","dollyStart","handleMouseDownPan","panStart","handleMouseMoveRotate","rotateEnd","rotateDelta","subVectors","element","body","rotateSpeed","copy","handleMouseMoveDolly","dollyEnd","dollyDelta","handleMouseMovePan","panEnd","panDelta","pan","handleMouseUp","handleMouseWheel","wheelDelta","detail","handleKeyDown","keyCode","UP","keyPanSpeed","BOTTOM","LEFT","RIGHT","handleTouchStartRotate","touches","pageX","pageY","handleTouchStartDolly","handleTouchStartPan","handleTouchMoveRotate","handleTouchMoveDolly","handleTouchMovePan","handleTouchEnd","onMouseDown","preventDefault","button","mouseButtons","ORBIT","enableRotate","state","STATE","ROTATE","ZOOM","DOLLY","PAN","enablePan","NONE","onMouseMove","onMouseUp","dispatchEvent","startEvent","removeEventListener","endEvent","onMouseWheel","stopPropagation","onKeyDown","enableKeys","onTouchStart","TOUCH_ROTATE","TOUCH_DOLLY","TOUCH_PAN","onTouchMove","onTouchEnd","onContextMenu","Vector3","minDistance","maxDistance","Infinity","minPolarAngle","minAzimuthAngle","maxAzimuthAngle","enableDamping","dampingFactor","autoRotate","MOUSE","MIDDLE","target0","position0","zoom0","getPolarAngle","getAzimuthalAngle","theta","reset","changeEvent","offset","quat","Quaternion","setFromUnitVectors","up","quatInverse","lastPosition","lastQuaternion","sub","applyQuaternion","EPS","radius","panOffset","lookAt","distanceToSquared","dot","quaternion","dispose","Vector2","panLeft","objectMatrix","te","elements","multiplyScalar","panUp","adjDist","deltaX","deltaY","targetDistance","fov","matrix","right","left","top","bottom","EventDispatcher","center","noRotate","noPan","noKeys","staticMoving","constraint","dynamicDampingFactor","_Layer2","_Layer3","_Skybox","_Skybox2","_Layer","_options","_initLights","_initSkybox","_skyboxLight","DirectionalLight","castShadow","shadow","near","far","mapSize","width","height","directionalLight","intesity","directionalLight2","helper","DirectionalLightHelper","helper2","_skybox","_mesh","size","step","gridHelper","GridHelper","_engineScene","Layer","Object3D","addLayer","_onAdd","child","children","geometry","material","map","_Sky","_Sky2","_lodashThrottle","_lodashThrottle2","cubemap","vertexShader","join","fragmentShader","Skybox","light","_light","_settings","turbidity","reileigh","mieCoefficient","mieDirectionalG","luminance","inclination","azimuth","_updateUniforms","_throttledWorldUpdate","_cubeCamera","CubeCamera","cubeTarget","renderTarget","_sky","_skyScene","mesh","_sunSphere","Mesh","SphereBufferGeometry","MeshBasicMaterial","color","skyboxUniforms","skyboxMat","ShaderMaterial","uniforms","side","BackSide","BoxGeometry","settings","sunPosition","_done","intensity","updateCubeMap","ShaderLib","Sky","skyShader","skyUniforms","UniformsUtils","skyMat","skyGeo","skyMesh","throttle","wait","leading","trailing","debounce","maxWait","cancel","timeoutId","clearTimeout","maxTimeoutId","lastCalled","trailingCall","complete","isCalled","now","delayed","remaining","stamp","setTimeout","flush","maxDelayed","debounced","leadingCall","Date","_TileLayer2","_TileLayer3","_ImageTile","_ImageTile2","_ImageTileLayerBaseMaterial","_ImageTileLayerBaseMaterial2","_TileLayer","path","_path","baseMaterial","geom","PlaneBufferGeometry","getRenderTarget","rotation","receiveShadow","_baseLayer","_calculateLOD","_onWorldUpdate","_onWorldMove","_moveBaseLayer","quadcode","_TileCache","_TileCache2","TileLayer","maxCache","maxLOD","_tileCache","tile","_destroyTile","_minLOD","_maxLOD","_tiles","getCamera","projScreenMatrix","Matrix4","multiplyMatrices","projectionMatrix","matrixWorldInverse","setFromMatrix","getBounds","intersectsBox","Box3","_this2","_stop","_updateFrustum","checkList","_checklist","_requestTile","_divide","_removeTiles","_tileInFrustum","getCenter","dist","getMesh","isReady","requestTileAsync","currentItem","count","getQuadcode","_screenSpaceError","minDepth","maxDepth","quality","error","getSide","getTile","_createTile","setTile","_lruCache","_lruCache2","TileCache","cacheLimit","onDestroyTile","_cache","priv","val","sym","symbols","makeSymbol","naiveLength","LRUCache","lc","stale","maxAge","forEachStep","self","node","thisp","hit","isStale","del","doUse","unshiftNode","diff","trim","walker","tail","prev","removeNode","Entry","Map","util","Yallist","hasSymbol","Symbol","mL","allowStale","mA","lC","rforEach","head","next","toArray","values","dump","filter","dumpLru","inspect","opts","str","extras","as","didFirst","item","split","has","unshift","peek","pop","load","arr","expiresAt","prune","process","env","npm_package_name","npm_lifecycle_script","TEST_PSEUDOMAP","cleanUpNextTick","draining","currentQueue","queue","concat","queueIndex","drainQueue","timeout","run","Item","fun","noop","nextTick","title","browser","argv","versions","binding","name","cwd","chdir","dir","umask","PseudoMap","clear","kv","same","_index","find","data","_data","res","entries","global","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","arrayToHash","hash","idx","recurseTimes","ret","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","isError","formatError","isRegExp","RegExp","isDate","base","braces","toUTCString","output","formatArray","formatProperty","reduceToSingleString","simple","JSON","stringify","isNumber","isNull","match","line","substr","numLinesEst","reduce","cur","ar","arg","isNullOrUndefined","isSymbol","re","isPrimitive","o","pad","timestamp","time","getHours","getMinutes","getSeconds","getDate","months","getMonth","prop","formatRegExp","format","f","objects","Number","_","deprecate","msg","deprecated","warned","throwDeprecation","traceDeprecation","trace","noDeprecation","debugEnviron","debugs","debuglog","NODE_DEBUG","toUpperCase","pid","bold","italic","underline","white","grey","black","blue","cyan","green","magenta","red","yellow","special","number","boolean","null","string","date","regexp","isBuffer","inherits","origin","fill","readUInt8","ctor","superCtor","super_","TempCtor","list","Node","pushNode","shift","forEachReverse","getReverse","mapReverse","initial","acc","reduceReverse","toArrayReverse","from","to","sliceReverse","reverse","_Tile2","_Tile3","_vendorBoxHelper","ImageTile","_Tile","_createMesh","_abortRequest","_image","_center","_side","MeshStandardMaterial","depthWrite","roughness","metalness","envMap","localMesh","renderOrder","canvas","createElement","getContext","font","fillStyle","fillText","_quadcode","_tile","texture","Texture","magFilter","LinearFilter","minFilter","LinearMipMapLinearFilter","anisotropy","needsUpdate","transparent","urlParams","url","_getTileURL","image","_texture","_ready","crossOrigin","src","r2d","tileURLRegex","Tile","_quadcodeToTile","_boundsLatLon","_tileBoundsWGS84","_boundsWorld","_tileBoundsFromWGS84","_boundsToCenter","_centerLatlon","_getSide","_pointScale","fromCharCode","floor","random","lastIndex","mask","q","boundsWGS84","sw","ne","_tile2lon","w","_tile2lat","BoxHelper","indices","Uint16Array","positions","Float32Array","BufferGeometry","setIndex","BufferAttribute","addAttribute","LineSegments","LineBasicMaterial","linewidth","box","setFromObject","isEmpty","attributes","computeBoundingSphere","colour","skyboxTarget","fillRect","_TopoJSONTile","_TopoJSONTile2","_reqwest","_reqwest2","_topojson","_topojson2","_earcut","_earcut2","_utilExtrudePolygon","_utilExtrudePolygon2","_polygonOffset","_polygonOffset2","TopoJSONTile","_request","coordinates","_coords","_offset","_shadowCanvas","ring","beginPath","coord","xFrac","yFrac","padding","moveTo","lineTo","closePath","_this3","then","_processTileData","err","_this4","geojson","feature","vectile","earcutData","faces","allVertices","allFaces","allColours","facesCount","Color","features","coordinate","_toEarcut","_triangulate","vertices","holes","dimensions","groupedVertices","il","extruded","topColor","multiply","bottomColor","_faces","_colours","_colour","face","fi","g","sides","_vertices","normals","colours","pA","pB","pC","cb","ab","ax","ay","az","c1","bx","by","bz","c2","cx","cy","cz","c3","cross","normalize","nx","ny","nz","computeBoundingBox","vertexColors","VertexColors","envMapIntensity","MeshPhongMaterial","timeEnd","dim","holeIndex","contour","abort","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_RESULT__","definition","succeed","protocol","protocolRe","exec","location","httpsRe","twoHundo","request","status","response","handleReadyState","success","_aborted","_timedOut","readyState","onreadystatechange","setHeaders","http","headers","defaultHeaders","isAFormData","FormData","requestedWith","contentType","setRequestHeader","setCredentials","withCredentials","generalCallback","lastValue","urlappend","handleJsonp","reqId","uniqid","cbkey","cbval","reqwest","getcallbackPrefix","cbreg","script","doc","isIE10","navigator","userAgent","async","htmlFor","onload","onclick","removeChild","getRequest","method","toQueryString","sendWait","xhr","open","xDomainRequest","onerror","onprogress","send","Reqwest","init","setType","header","resp","_completeHandlers","getResponseHeader","filteredResponse","globalSetupOptions","dataFilter","responseText","parse","eval","responseXML","parseError","errorCode","reason","_responseArgs","_fulfilled","_successHandler","_fulfillmentHandlers","timedOut","t","_erred","_errorHandlers","serial","el","ch","ra","tagName","toLowerCase","optCb","disabled","checked","selectedIndex","selected","eachFormElement","serializeSubtags","tags","fa","byTag","serializeQueryString","serializeArray","serializeHash","buildParams","traditional","rbracket","XHR2","ex","callbackPrefix","xmlHttpRequest","accept","*","xml","html","text","json","js","XMLHttpRequest","XDomainRequest","ActiveXObject","retry","fail","always","catch","serialize","opt","nodeType","trad","enc","encodeURIComponent","compat","ajaxSetup","absolute","x0","y0","kx","ky","translate","relative","x1","y1","bisect","lo","hi","mid","topology","geometries","feature$1","properties","arc","points","arcs","absolute$$","polygon","geometryType","MultiPoint","LineString","MultiLineString","Polygon","MultiPolygon","stitchArcs","ends","p0","dp","fragmentByEnd","fragmentByStart","end","stitchedArcs","fragments","emptyIndex","fg","gf","meshArcs","geomsByArc","geoms","triangle","area","merge","mergeArcs","register","ring$$","polygonsByArc","polygons","exterior","components","component","neighbors","sgn","indexesByArc","ij","ik","compareArea","minAreaHeap","down","heap","removed","presimplify","triangleArea","relative$$","triangles","maxArea","previous","earcut","holeIndices","hasHoles","outerLen","outerNode","linkedList","minX","minY","maxX","maxY","eliminateHoles","earcutLinked","clockwise","last","sum","insertNode","filterPoints","again","steiner","equals","ear","pass","indexCurve","stop","isEarHashed","isEar","cureLocalIntersections","splitEarcut","pointInTriangle","minTX","minTY","maxTX","maxTY","minZ","zOrder","maxZ","nextZ","prevZ","intersects","locallyInside","isValidDiagonal","splitPolygon","getLeftmost","sort","compareX","eliminateHole","hole","findHoleBridge","hx","hy","qx","tanMin","sortLinked","numMerges","pSize","qSize","inSize","leftmost","px","py","intersectsPolygon","middleInside","q1","q2","inside","b2","an","bp","extrudePolygon","flat","cells","topCells","full","sideCells","closed","bottomCells","Offset","arcSegments","edges","_closed","_arcSegments","GreinerHormann","Edge","intersection","validate","createArc","startVertex","endVertex","segments","outwards","PI2","startAngle","endAngle","segmentAngle","union","offsetEdges","edge","_outNormal","thisEdge","prevEdge","vertex","current","ensureLastPoint","margin","_inNormal","clip","polygonA","polygonB","eA","eB","Vertex","Intersection","arrayVertices","first","_lastUnprocessed","_arrayVertices","addVertex","insertVertex","curr","_distance","getNext","_isIntersection","getFirstIntersect","_firstIntersect","_visited","hasUnprocessed","getPoints","sourceForwards","clipForwards","sourceInClip","clipInSource","sourceVertex","clipVertex","valid","sourceIntersection","createIntersection","toSource","clipIntersection","toClip","_corresponding","isInside","_isEntry","clipped","visit","poly","oddNodes","s1","s2","inwardsNormal","outwardsNormal","inwards","edgeLength","A0","A1","B0","B1","den","ua","ub"],"mappings":"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","file":"vizicities.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"proj4\"), require(\"THREE\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"proj4\", \"THREE\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"VIZI\"] = factory(require(\"proj4\"), require(\"THREE\"));\n\telse\n\t\troot[\"VIZI\"] = factory(root[\"proj4\"], root[\"THREE\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_22__, __WEBPACK_EXTERNAL_MODULE_24__) {\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(\"proj4\"), require(\"THREE\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"proj4\", \"THREE\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"VIZI\"] = factory(require(\"proj4\"), require(\"THREE\"));\n\telse\n\t\troot[\"VIZI\"] = factory(root[\"proj4\"], root[\"THREE\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_22__, __WEBPACK_EXTERNAL_MODULE_24__) {\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 _World = __webpack_require__(1);\n\t\n\tvar _World2 = _interopRequireDefault(_World);\n\t\n\tvar _controlsIndex = __webpack_require__(28);\n\t\n\tvar _controlsIndex2 = _interopRequireDefault(_controlsIndex);\n\t\n\tvar _layerEnvironmentEnvironmentLayer = __webpack_require__(31);\n\t\n\tvar _layerEnvironmentEnvironmentLayer2 = _interopRequireDefault(_layerEnvironmentEnvironmentLayer);\n\t\n\tvar _layerTileImageTileLayer = __webpack_require__(37);\n\t\n\tvar _layerTileImageTileLayer2 = _interopRequireDefault(_layerTileImageTileLayer);\n\t\n\tvar _layerTileTopoJSONTileLayer = __webpack_require__(52);\n\t\n\tvar _layerTileTopoJSONTileLayer2 = _interopRequireDefault(_layerTileTopoJSONTileLayer);\n\t\n\tvar _geoPoint = __webpack_require__(11);\n\t\n\tvar _geoPoint2 = _interopRequireDefault(_geoPoint);\n\t\n\tvar _geoLatLon = __webpack_require__(10);\n\t\n\tvar _geoLatLon2 = _interopRequireDefault(_geoLatLon);\n\t\n\tvar VIZI = {\n\t version: '0.3',\n\t\n\t // Public API\n\t World: _World2['default'],\n\t Controls: _controlsIndex2['default'],\n\t EnvironmentLayer: _layerEnvironmentEnvironmentLayer2['default'],\n\t ImageTileLayer: _layerTileImageTileLayer2['default'],\n\t TopoJSONTileLayer: _layerTileTopoJSONTileLayer2['default'],\n\t Point: _geoPoint2['default'],\n\t LatLon: _geoLatLon2['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 _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__(2);\n\t\n\tvar _eventemitter32 = _interopRequireDefault(_eventemitter3);\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _geoCRSIndex = __webpack_require__(6);\n\t\n\tvar _geoCRSIndex2 = _interopRequireDefault(_geoCRSIndex);\n\t\n\tvar _geoPoint = __webpack_require__(11);\n\t\n\tvar _geoPoint2 = _interopRequireDefault(_geoPoint);\n\t\n\tvar _geoLatLon = __webpack_require__(10);\n\t\n\tvar _geoLatLon2 = _interopRequireDefault(_geoLatLon);\n\t\n\tvar _engineEngine = __webpack_require__(23);\n\t\n\tvar _engineEngine2 = _interopRequireDefault(_engineEngine);\n\t\n\t// Pretty much any event someone using ViziCities would need will be emitted or\n\t// proxied by World (eg. render events, etc)\n\t\n\tvar World = (function (_EventEmitter) {\n\t _inherits(World, _EventEmitter);\n\t\n\t function World(domId, options) {\n\t _classCallCheck(this, World);\n\t\n\t _get(Object.getPrototypeOf(World.prototype), 'constructor', this).call(this);\n\t\n\t var defaults = {\n\t crs: _geoCRSIndex2['default'].EPSG3857,\n\t skybox: false\n\t };\n\t\n\t this.options = (0, _lodashAssign2['default'])(defaults, options);\n\t\n\t this._layers = [];\n\t this._controls = [];\n\t\n\t this._initContainer(domId);\n\t this._initEngine();\n\t this._initEnvironment();\n\t this._initEvents();\n\t\n\t // Kick off the update and render loop\n\t this._update();\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t _createClass(World, [{\n\t key: '_initContainer',\n\t value: function _initContainer(domId) {\n\t this._container = document.getElementById(domId);\n\t }\n\t }, {\n\t key: '_initEngine',\n\t value: function _initEngine() {\n\t this._engine = (0, _engineEngine2['default'])(this._container);\n\t\n\t // Engine events\n\t //\n\t // Consider proxying these through events on World for public access\n\t // this._engine.on('preRender', () => {});\n\t // this._engine.on('postRender', () => {});\n\t }\n\t }, {\n\t key: '_initEnvironment',\n\t value: function _initEnvironment() {\n\t // Not sure if I want to keep this as a private API\n\t //\n\t // Makes sense to allow others to customise their environment so perhaps\n\t // add some method of disable / overriding the environment settings\n\t this._environment = VIZI.EnvironmentLayer({\n\t skybox: this.options.skybox\n\t }).addTo(this);\n\t }\n\t }, {\n\t key: '_initEvents',\n\t value: function _initEvents() {\n\t this.on('controlsMoveEnd', this._onControlsMoveEnd);\n\t }\n\t }, {\n\t key: '_onControlsMoveEnd',\n\t value: function _onControlsMoveEnd(point) {\n\t var _point = (0, _geoPoint2['default'])(point.x, point.z);\n\t this._resetView(this.pointToLatLon(_point), _point);\n\t }\n\t\n\t // Reset world view\n\t }, {\n\t key: '_resetView',\n\t value: function _resetView(latlon, point) {\n\t this.emit('preResetView');\n\t\n\t this._moveStart();\n\t this._move(latlon, point);\n\t this._moveEnd();\n\t\n\t this.emit('postResetView');\n\t }\n\t }, {\n\t key: '_moveStart',\n\t value: function _moveStart() {\n\t this.emit('moveStart');\n\t }\n\t }, {\n\t key: '_move',\n\t value: function _move(latlon, point) {\n\t this._lastPosition = latlon;\n\t this.emit('move', latlon, point);\n\t }\n\t }, {\n\t key: '_moveEnd',\n\t value: function _moveEnd() {\n\t this.emit('moveEnd');\n\t }\n\t }, {\n\t key: '_update',\n\t value: function _update() {\n\t var delta = this._engine.clock.getDelta();\n\t\n\t // Once _update is called it will run forever, for now\n\t window.requestAnimationFrame(this._update.bind(this));\n\t\n\t // Update controls\n\t this._controls.forEach(function (controls) {\n\t controls.update();\n\t });\n\t\n\t this.emit('preUpdate', delta);\n\t this._engine.update(delta);\n\t this.emit('postUpdate', delta);\n\t }\n\t\n\t // Set world view\n\t }, {\n\t key: 'setView',\n\t value: function setView(latlon) {\n\t // Store initial geographic coordinate for the [0,0,0] world position\n\t //\n\t // The origin point doesn't move in three.js / 3D space so only set it once\n\t // here instead of every time _resetView is called\n\t //\n\t // If it was updated every time then coorindates would shift over time and\n\t // would be out of place / context with previously-placed points (0,0 would\n\t // refer to a different point each time)\n\t this._originLatlon = latlon;\n\t this._originPoint = this.project(latlon);\n\t\n\t this._resetView(latlon);\n\t return this;\n\t }\n\t\n\t // Return world geographic position\n\t }, {\n\t key: 'getPosition',\n\t value: function getPosition() {\n\t return this._lastPosition;\n\t }\n\t\n\t // Transform geographic coordinate to world point\n\t //\n\t // This doesn't take into account the origin offset\n\t //\n\t // For example, this takes a geographic coordinate and returns a point\n\t // relative to the origin point of the projection (not the world)\n\t }, {\n\t key: 'project',\n\t value: function project(latlon) {\n\t return this.options.crs.latLonToPoint((0, _geoLatLon2['default'])(latlon));\n\t }\n\t\n\t // Transform world point to geographic coordinate\n\t //\n\t // This doesn't take into account the origin offset\n\t //\n\t // For example, this takes a point relative to the origin point of the\n\t // projection (not the world) and returns a geographic coordinate\n\t }, {\n\t key: 'unproject',\n\t value: function unproject(point) {\n\t return this.options.crs.pointToLatLon((0, _geoPoint2['default'])(point));\n\t }\n\t\n\t // Takes into account the origin offset\n\t //\n\t // For example, this takes a geographic coordinate and returns a point\n\t // relative to the three.js / 3D origin (0,0)\n\t }, {\n\t key: 'latLonToPoint',\n\t value: function latLonToPoint(latlon) {\n\t var projectedPoint = this.project((0, _geoLatLon2['default'])(latlon));\n\t return projectedPoint._subtract(this._originPoint);\n\t }\n\t\n\t // Takes into account the origin offset\n\t //\n\t // For example, this takes a point relative to the three.js / 3D origin (0,0)\n\t // and returns the exact geographic coordinate at that point\n\t }, {\n\t key: 'pointToLatLon',\n\t value: function pointToLatLon(point) {\n\t var projectedPoint = (0, _geoPoint2['default'])(point).add(this._originPoint);\n\t return this.unproject(projectedPoint);\n\t }\n\t\n\t // Return pointscale for a given geographic coordinate\n\t }, {\n\t key: 'pointScale',\n\t value: function pointScale(latlon, accurate) {\n\t return this.options.crs.pointScale(latlon, accurate);\n\t }\n\t\n\t // Convert from real meters to world units\n\t //\n\t // TODO: Would be nice not to have to pass in a pointscale here\n\t }, {\n\t key: 'metresToWorld',\n\t value: function metresToWorld(metres, pointScale, zoom) {\n\t return this.options.crs.metresToWorld(metres, pointScale, zoom);\n\t }\n\t\n\t // Convert from real meters to world units\n\t //\n\t // TODO: Would be nice not to have to pass in a pointscale here\n\t }, {\n\t key: 'worldToMetres',\n\t value: function worldToMetres(worldUnits, pointScale, zoom) {\n\t return this.options.crs.worldToMetres(worldUnits, pointScale, zoom);\n\t }\n\t\n\t // Unsure if it's a good idea to expose this here for components like\n\t // GridLayer to use (eg. to keep track of a frustum)\n\t }, {\n\t key: 'getCamera',\n\t value: function getCamera() {\n\t return this._engine._camera;\n\t }\n\t }, {\n\t key: 'addLayer',\n\t value: function addLayer(layer) {\n\t layer._addToWorld(this);\n\t\n\t this._layers.push(layer);\n\t\n\t // Could move this into Layer but it'll do here for now\n\t this._engine._scene.add(layer._layer);\n\t\n\t this.emit('layerAdded', layer);\n\t return this;\n\t }\n\t\n\t // Remove layer and perform clean up operations\n\t }, {\n\t key: 'removeLayer',\n\t value: function removeLayer(layer) {\n\t var layerIndex = this._layers.indexOf(layer);\n\t\n\t if (layerIndex > -1) {\n\t // Remove from this._layers\n\t this._layers.splice(layerIndex, 1);\n\t };\n\t\n\t this._engine._scene.remove(layer._layer);\n\t\n\t layer.destroy();\n\t\n\t this.emit('layerRemoved');\n\t return this;\n\t }\n\t }, {\n\t key: 'addControls',\n\t value: function addControls(controls) {\n\t controls._addToWorld(this);\n\t\n\t this._controls.push(controls);\n\t\n\t this.emit('controlsAdded', controls);\n\t return this;\n\t }\n\t }, {\n\t key: 'removeControls',\n\t value: function removeControls(controls) {}\n\t }]);\n\t\n\t return World;\n\t})(_eventemitter32['default']);\n\t\n\texports['default'] = function (domId, options) {\n\t return new World(domId, options);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\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 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 * Holds 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 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 {Functon} fn Callback function.\n\t * @param {Mixed} context 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 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/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * lodash 4.0.2 (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t * Available under MIT license <https://lodash.com/license>\n\t */\n\tvar keys = __webpack_require__(4),\n\t rest = __webpack_require__(5);\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/**\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 value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n\t length = length == null ? MAX_SAFE_INTEGER : length;\n\t return value > -1 && value % 1 == 0 && value < length;\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 [`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/**\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 ((!eq(objValue, value) ||\n\t (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) ||\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 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 names to copy.\n\t * @param {Object} [object={}] The object to copy properties to.\n\t * @returns {Object} Returns `object`.\n\t */\n\tfunction copyObject(source, props, object) {\n\t return copyObjectWith(source, props, object);\n\t}\n\t\n\t/**\n\t * This function is like `copyObject` except that it accepts a function to\n\t * customize copied values.\n\t *\n\t * @private\n\t * @param {Object} source The object to copy properties from.\n\t * @param {Array} props The property names 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 copyObjectWith(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 newValue = customizer ? customizer(object[key], source[key], key, object, source) : 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 = typeof customizer == 'function' ? (length--, customizer) : undefined;\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 [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n\t * that affects 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 the provided 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, 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 return eq(object[index], value);\n\t }\n\t return false;\n\t}\n\t\n\t/**\n\t * Performs a [`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 * @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 * @type Function\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 &&\n\t !(typeof value == 'function' && isFunction(value)) && isLength(getLength(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 * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n\t // 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 [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a valid length, 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' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n\t}\n\t\n\t/**\n\t * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n\t * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\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 properties of source objects to the destination\n\t * object. Source objects are applied from left to right. Subsequent sources\n\t * 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 * @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 * @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 copyObject(source, keys(source), object);\n\t});\n\t\n\tmodule.exports = assign;\n\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\t/**\n\t * lodash 4.0.2 (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t * Available under MIT license <https://lodash.com/license>\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/**\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 value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n\t length = length == null ? MAX_SAFE_INTEGER : length;\n\t return value > -1 && value % 1 == 0 && value < length;\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 [`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 getPrototypeOf = Object.getPrototypeOf,\n\t propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\t\n\t/* Built-in method references for those with the same name as other `lodash` methods. */\n\tvar 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 && getPrototypeOf(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 * @type Function\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 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 [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n\t * that affects 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 * 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 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 * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified, 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 * @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, 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 * @type Function\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 &&\n\t !(typeof value == 'function' && isFunction(value)) && isLength(getLength(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 * @type Function\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, 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 * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n\t // 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 [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a valid length, 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' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n\t}\n\t\n\t/**\n\t * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n\t * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\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 * @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 * @memberOf _\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified, 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 * @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/* 5 */\n/***/ function(module, exports) {\n\n\t/**\n\t * lodash 4.0.1 (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t * Available under MIT license <https://lodash.com/license>\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\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 {...*} 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 [`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 an array.\n\t *\n\t * **Note:** This method is based on the [rest parameter](https://mdn.io/rest_parameters).\n\t *\n\t * @static\n\t * @memberOf _\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 * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n\t // 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 [language type](https://es5.github.io/#x8) of `Object`.\n\t * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\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 * Converts `value` to an integer.\n\t *\n\t * **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).\n\t *\n\t * @static\n\t * @memberOf _\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);\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');\n\t * // => 3\n\t */\n\tfunction toInteger(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 var remainder = value % 1;\n\t return value === value ? (remainder ? value - remainder : value) : 0;\n\t}\n\t\n\t/**\n\t * Converts `value` to a number.\n\t *\n\t * @static\n\t * @memberOf _\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);\n\t * // => 3\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');\n\t * // => 3\n\t */\n\tfunction toNumber(value) {\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/* 6 */\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 _CRSEPSG3857 = __webpack_require__(7);\n\t\n\tvar _CRSEPSG38572 = _interopRequireDefault(_CRSEPSG3857);\n\t\n\tvar _CRSEPSG3395 = __webpack_require__(15);\n\t\n\tvar _CRSEPSG33952 = _interopRequireDefault(_CRSEPSG3395);\n\t\n\tvar _CRSEPSG4326 = __webpack_require__(17);\n\t\n\tvar _CRSEPSG43262 = _interopRequireDefault(_CRSEPSG4326);\n\t\n\tvar _CRSSimple = __webpack_require__(19);\n\t\n\tvar _CRSSimple2 = _interopRequireDefault(_CRSSimple);\n\t\n\tvar _CRSProj4 = __webpack_require__(20);\n\t\n\tvar _CRSProj42 = _interopRequireDefault(_CRSProj4);\n\t\n\tvar CRS = {};\n\t\n\tCRS.EPSG3857 = _CRSEPSG38572['default'];\n\tCRS.EPSG900913 = _CRSEPSG3857.EPSG900913;\n\tCRS.EPSG3395 = _CRSEPSG33952['default'];\n\tCRS.EPSG4326 = _CRSEPSG43262['default'];\n\tCRS.Simple = _CRSSimple2['default'];\n\tCRS.Proj4 = _CRSProj42['default'];\n\t\n\texports['default'] = CRS;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 7 */\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 * CRS.EPSG3857 (WGS 84 / Pseudo-Mercator) CRS implementation.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.EPSG3857.js\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _CRSEarth = __webpack_require__(8);\n\t\n\tvar _CRSEarth2 = _interopRequireDefault(_CRSEarth);\n\t\n\tvar _projectionProjectionSphericalMercator = __webpack_require__(13);\n\t\n\tvar _projectionProjectionSphericalMercator2 = _interopRequireDefault(_projectionProjectionSphericalMercator);\n\t\n\tvar _utilTransformation = __webpack_require__(14);\n\t\n\tvar _utilTransformation2 = _interopRequireDefault(_utilTransformation);\n\t\n\tvar _EPSG3857 = {\n\t code: 'EPSG:3857',\n\t projection: _projectionProjectionSphericalMercator2['default'],\n\t\n\t // Work out how to de-dupe this (scoping issue)\n\t transformScale: 1 / (Math.PI * _projectionProjectionSphericalMercator2['default'].R),\n\t\n\t // Scale and transformation inputs changed to account for central origin in\n\t // WebGL, instead of top-left origin used in Leaflet\n\t transformation: (function () {\n\t // TODO: Cannot use this.transformScale due to scope\n\t var scale = 1 / (Math.PI * _projectionProjectionSphericalMercator2['default'].R);\n\t\n\t return new _utilTransformation2['default'](scale, 0, -scale, 0);\n\t })()\n\t};\n\t\n\tvar EPSG3857 = (0, _lodashAssign2['default'])({}, _CRSEarth2['default'], _EPSG3857);\n\t\n\tvar EPSG900913 = (0, _lodashAssign2['default'])({}, EPSG3857, {\n\t code: 'EPSG:900913'\n\t});\n\t\n\texports.EPSG900913 = EPSG900913;\n\texports['default'] = EPSG3857;\n\n/***/ },\n/* 8 */\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 * CRS.Earth is the base class for all CRS representing Earth.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.Earth.js\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _CRS = __webpack_require__(9);\n\t\n\tvar _CRS2 = _interopRequireDefault(_CRS);\n\t\n\tvar _LatLon = __webpack_require__(10);\n\t\n\tvar _LatLon2 = _interopRequireDefault(_LatLon);\n\t\n\tvar Earth = {\n\t wrapLon: [-180, 180],\n\t\n\t R: 6378137,\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\t distance: function distance(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 this.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 this.R * c;\n\t }\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 // Defaults to a scale factor of 1 if no calculation method exists\n\t //\n\t // Probably need to run this through the CRS transformation or similar so the\n\t // resulting scale is relative to the dimensions of the world space\n\t // Eg. 1 metre in projected space is likly scaled up or down to some other\n\t // number\n\t pointScale: function pointScale(latlon, accurate) {\n\t return this.projection.pointScale ? this.projection.pointScale(latlon, accurate) : [1, 1];\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\t metresToProjected: function metresToProjected(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\t projectedToMetres: function projectedToMetres(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\t metresToWorld: function metresToWorld(metres, pointScale, zoom) {\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 = this.metresToProjected(metres, pointScale);\n\t\n\t var scale = this.scale(zoom);\n\t\n\t // Half scale if using zoom as WebGL origin is in the centre, not top left\n\t if (zoom) {\n\t scale /= 2;\n\t }\n\t\n\t // Scale projected metres\n\t var scaledMetres = scale * (this.transformScale * projectedMetres);\n\t\n\t // Not entirely sure why this is neccessary\n\t if (zoom) {\n\t scaledMetres /= pointScale[1];\n\t }\n\t\n\t return scaledMetres;\n\t },\n\t\n\t // Convert world (WebGL) units to a value in real metres\n\t worldToMetres: function worldToMetres(worldUnits, pointScale, zoom) {\n\t var scale = this.scale(zoom);\n\t\n\t // Half scale if using zoom as WebGL origin is in the centre, not top left\n\t if (zoom) {\n\t scale /= 2;\n\t }\n\t\n\t var projectedUnits = worldUnits / scale / this.transformScale;\n\t var realMetres = this.projectedToMetres(projectedUnits, pointScale);\n\t\n\t // Not entirely sure why this is neccessary\n\t if (zoom) {\n\t realMetres *= pointScale[1];\n\t }\n\t\n\t return realMetres;\n\t }\n\t};\n\t\n\texports['default'] = (0, _lodashAssign2['default'])({}, _CRS2['default'], Earth);\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 9 */\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 * CRS is the base object for all defined CRS (Coordinate Reference Systems)\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.js\n\t */\n\t\n\tvar _LatLon = __webpack_require__(10);\n\t\n\tvar _LatLon2 = _interopRequireDefault(_LatLon);\n\t\n\tvar _Point = __webpack_require__(11);\n\t\n\tvar _Point2 = _interopRequireDefault(_Point);\n\t\n\tvar _utilWrapNum = __webpack_require__(12);\n\t\n\tvar _utilWrapNum2 = _interopRequireDefault(_utilWrapNum);\n\t\n\tvar CRS = {\n\t // Scale factor determines final dimensions of world space\n\t //\n\t // Projection transformation in range -1 to 1 is multiplied by scale factor to\n\t // find final world coordinates\n\t //\n\t // Scale factor can be considered as half the amount of the desired dimension\n\t // for the largest side when transformation is equal to 1 or -1, or as the\n\t // distance between 0 and 1 on the largest side\n\t //\n\t // For example, if you want the world dimensions to be between -1000 and 1000\n\t // then the scale factor will be 1000\n\t scaleFactor: 1000000,\n\t\n\t // Converts geo coords to pixel / WebGL ones\n\t latLonToPoint: function latLonToPoint(latlon, zoom) {\n\t var projectedPoint = this.projection.project(latlon);\n\t var scale = this.scale(zoom);\n\t\n\t // Half scale if using zoom as WebGL origin is in the centre, not top left\n\t if (zoom) {\n\t scale /= 2;\n\t }\n\t\n\t return this.transformation._transform(projectedPoint, scale);\n\t },\n\t\n\t // Converts pixel / WebGL coords to geo coords\n\t pointToLatLon: function pointToLatLon(point, zoom) {\n\t var scale = this.scale(zoom);\n\t\n\t // Half scale if using zoom as WebGL origin is in the centre, not top left\n\t if (zoom) {\n\t scale /= 2;\n\t }\n\t\n\t var untransformedPoint = this.transformation.untransform(point, scale);\n\t\n\t return this.projection.unproject(untransformedPoint);\n\t },\n\t\n\t // Converts geo coords to projection-specific coords (e.g. in meters)\n\t project: function project(latlon) {\n\t return this.projection.project(latlon);\n\t },\n\t\n\t // Converts projected coords to geo coords\n\t unproject: function unproject(point) {\n\t return this.projection.unproject(point);\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\t scale: function scale(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 this.scaleFactor;\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\t zoom: function zoom(scale) {\n\t return Math.log(scale / 256) / Math.LN2;\n\t },\n\t\n\t // Returns the bounds of the world in projected coords if applicable\n\t getProjectedBounds: function getProjectedBounds(zoom) {\n\t if (this.infinite) {\n\t return null;\n\t }\n\t\n\t var b = this.projection.bounds;\n\t var s = this.scale(zoom);\n\t\n\t // Half scale if using zoom as WebGL origin is in the centre, not top left\n\t if (zoom) {\n\t s /= 2;\n\t }\n\t\n\t // Bottom left\n\t var min = this.transformation.transform((0, _Point2['default'])(b[0]), s);\n\t\n\t // Top right\n\t var max = this.transformation.transform((0, _Point2['default'])(b[1]), s);\n\t\n\t return [min, max];\n\t },\n\t\n\t // Whether a coordinate axis wraps in a given range (e.g. longitude from -180 to 180); depends on CRS\n\t // wrapLon: [min, max],\n\t // wrapLat: [min, max],\n\t\n\t // If true, the coordinate space will be unbounded (infinite in all directions)\n\t // infinite: false,\n\t\n\t // Wraps geo coords in certain ranges if applicable\n\t wrapLatLon: function wrapLatLon(latlon) {\n\t var lat = this.wrapLat ? (0, _utilWrapNum2['default'])(latlon.lat, this.wrapLat, true) : latlon.lat;\n\t var lon = this.wrapLon ? (0, _utilWrapNum2['default'])(latlon.lon, this.wrapLon, true) : latlon.lon;\n\t var alt = latlon.alt;\n\t\n\t return (0, _LatLon2['default'])(lat, lon, alt);\n\t }\n\t};\n\t\n\texports['default'] = CRS;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 10 */\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 // Initialise without requiring new keyword\n\t //\n\t // Accepts (LatLon), ([lat, lon, alt]), ([lat, lon]) and (lat, lon, alt)\n\t // Also converts between lng and lon\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'] = function (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;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 11 */\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 // Accepts (point), ([x, y]) and (x, y, round)\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\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[\"default\"] = _point;\n\tmodule.exports = exports[\"default\"];\n\n/***/ },\n/* 12 */\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/* 13 */\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 * Spherical Mercator is the most popular map projection, used by EPSG:3857 CRS\n\t * used by default.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/projection/Projection.SphericalMercator.js\n\t */\n\t\n\tvar _LatLon = __webpack_require__(10);\n\t\n\tvar _LatLon2 = _interopRequireDefault(_LatLon);\n\t\n\tvar _Point = __webpack_require__(11);\n\t\n\tvar _Point2 = _interopRequireDefault(_Point);\n\t\n\tvar SphericalMercator = {\n\t // Radius / WGS84 semi-major axis\n\t R: 6378137,\n\t MAX_LATITUDE: 85.0511287798,\n\t\n\t // WGS84 eccentricity\n\t ECC: 0.081819191,\n\t ECC2: 0.081819191 * 0.081819191,\n\t\n\t project: function project(latlon) {\n\t var d = Math.PI / 180;\n\t var max = this.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, _Point2['default'])(this.R * latlon.lon * d, this.R * Math.log((1 + sin) / (1 - sin)) / 2);\n\t },\n\t\n\t unproject: function unproject(point) {\n\t var d = 180 / Math.PI;\n\t\n\t return (0, _LatLon2['default'])((2 * Math.atan(Math.exp(point.y / this.R)) - Math.PI / 2) * d, point.x * d / this.R);\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\t pointScale: function pointScale(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 = this.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 - this.ECC2) / Math.pow(1 - this.ECC2 * sinLat2, 3 / 2);\n\t\n\t // Radius prime meridian\n\t var v = a / Math.sqrt(1 - this.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 // Not using this.R due to scoping\n\t bounds: (function () {\n\t var d = 6378137 * Math.PI;\n\t return [[-d, -d], [d, d]];\n\t })()\n\t};\n\t\n\texports['default'] = SphericalMercator;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 14 */\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\t/*\n\t * Transformation is an utility class to perform simple point transformations\n\t * through a 2d-matrix.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geometry/Transformation.js\n\t */\n\t\n\tvar _geoPoint = __webpack_require__(11);\n\t\n\tvar _geoPoint2 = _interopRequireDefault(_geoPoint);\n\t\n\tvar Transformation = (function () {\n\t function Transformation(a, b, c, d) {\n\t _classCallCheck(this, Transformation);\n\t\n\t this._a = a;\n\t this._b = b;\n\t this._c = c;\n\t this._d = d;\n\t }\n\t\n\t _createClass(Transformation, [{\n\t key: 'transform',\n\t value: function transform(point, scale) {\n\t // Copy input point as to not destroy the original data\n\t return this._transform(point.clone(), scale);\n\t }\n\t\n\t // Destructive transform (faster)\n\t }, {\n\t key: '_transform',\n\t value: function _transform(point, scale) {\n\t scale = scale || 1;\n\t\n\t point.x = scale * (this._a * point.x + this._b);\n\t point.y = scale * (this._c * point.y + this._d);\n\t return point;\n\t }\n\t }, {\n\t key: 'untransform',\n\t value: function untransform(point, scale) {\n\t scale = scale || 1;\n\t return (0, _geoPoint2['default'])((point.x / scale - this._b) / this._a, (point.y / scale - this._d) / this._c);\n\t }\n\t }]);\n\t\n\t return Transformation;\n\t})();\n\t\n\texports['default'] = Transformation;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 15 */\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 * CRS.EPSG3395 (WGS 84 / World Mercator) CRS implementation.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.EPSG3395.js\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _CRSEarth = __webpack_require__(8);\n\t\n\tvar _CRSEarth2 = _interopRequireDefault(_CRSEarth);\n\t\n\tvar _projectionProjectionMercator = __webpack_require__(16);\n\t\n\tvar _projectionProjectionMercator2 = _interopRequireDefault(_projectionProjectionMercator);\n\t\n\tvar _utilTransformation = __webpack_require__(14);\n\t\n\tvar _utilTransformation2 = _interopRequireDefault(_utilTransformation);\n\t\n\tvar _EPSG3395 = {\n\t code: 'EPSG:3395',\n\t projection: _projectionProjectionMercator2['default'],\n\t\n\t // Work out how to de-dupe this (scoping issue)\n\t transformScale: 1 / (Math.PI * _projectionProjectionMercator2['default'].R),\n\t\n\t // Scale and transformation inputs changed to account for central origin in\n\t // WebGL, instead of top-left origin used in Leaflet\n\t transformation: (function () {\n\t // TODO: Cannot use this.transformScale due to scope\n\t var scale = 1 / (Math.PI * _projectionProjectionMercator2['default'].R);\n\t\n\t return new _utilTransformation2['default'](scale, 0, -scale, 0);\n\t })()\n\t};\n\t\n\tvar EPSG3395 = (0, _lodashAssign2['default'])({}, _CRSEarth2['default'], _EPSG3395);\n\t\n\texports['default'] = EPSG3395;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 16 */\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 * Mercator projection that takes into account that the Earth is not a perfect\n\t * sphere. Less popular than spherical mercator; used by projections like\n\t * EPSG:3395.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/projection/Projection.Mercator.js\n\t */\n\t\n\tvar _LatLon = __webpack_require__(10);\n\t\n\tvar _LatLon2 = _interopRequireDefault(_LatLon);\n\t\n\tvar _Point = __webpack_require__(11);\n\t\n\tvar _Point2 = _interopRequireDefault(_Point);\n\t\n\tvar Mercator = {\n\t // Radius / WGS84 semi-major axis\n\t R: 6378137,\n\t R_MINOR: 6356752.314245179,\n\t\n\t // WGS84 eccentricity\n\t ECC: 0.081819191,\n\t ECC2: 0.081819191 * 0.081819191,\n\t\n\t project: function project(latlon) {\n\t var d = Math.PI / 180;\n\t var r = this.R;\n\t var y = latlon.lat * d;\n\t var tmp = this.R_MINOR / r;\n\t var e = Math.sqrt(1 - tmp * tmp);\n\t var con = e * Math.sin(y);\n\t\n\t var ts = Math.tan(Math.PI / 4 - y / 2) / Math.pow((1 - con) / (1 + con), e / 2);\n\t y = -r * Math.log(Math.max(ts, 1E-10));\n\t\n\t return (0, _Point2['default'])(latlon.lon * d * r, y);\n\t },\n\t\n\t unproject: function unproject(point) {\n\t var d = 180 / Math.PI;\n\t var r = this.R;\n\t var tmp = this.R_MINOR / r;\n\t var e = Math.sqrt(1 - tmp * tmp);\n\t var ts = Math.exp(-point.y / r);\n\t var phi = Math.PI / 2 - 2 * Math.atan(ts);\n\t\n\t for (var i = 0, dphi = 0.1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {\n\t con = e * Math.sin(phi);\n\t con = Math.pow((1 - con) / (1 + con), e / 2);\n\t dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;\n\t phi += dphi;\n\t }\n\t\n\t return (0, _LatLon2['default'])(phi * d, point.x * d / r);\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 // See pg.8: http://www.hydrometronics.com/downloads/Web%20Mercator%20-%20Non-Conformal,%20Non-Mercator%20(notes).pdf\n\t pointScale: function pointScale(latlon) {\n\t var rad = Math.PI / 180;\n\t var lat = latlon.lat * rad;\n\t var sinLat = Math.sin(lat);\n\t var sinLat2 = sinLat * sinLat;\n\t var cosLat = Math.cos(lat);\n\t\n\t var k = Math.sqrt(1 - this.ECC2 * sinLat2) / cosLat;\n\t\n\t // [scaleX, scaleY]\n\t return [k, k];\n\t },\n\t\n\t bounds: [[-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]]\n\t};\n\t\n\texports['default'] = Mercator;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 17 */\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 * CRS.EPSG4326 is a CRS popular among advanced GIS specialists.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.EPSG4326.js\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _CRSEarth = __webpack_require__(8);\n\t\n\tvar _CRSEarth2 = _interopRequireDefault(_CRSEarth);\n\t\n\tvar _projectionProjectionLatLon = __webpack_require__(18);\n\t\n\tvar _projectionProjectionLatLon2 = _interopRequireDefault(_projectionProjectionLatLon);\n\t\n\tvar _utilTransformation = __webpack_require__(14);\n\t\n\tvar _utilTransformation2 = _interopRequireDefault(_utilTransformation);\n\t\n\tvar _EPSG4326 = {\n\t code: 'EPSG:4326',\n\t projection: _projectionProjectionLatLon2['default'],\n\t\n\t // Work out how to de-dupe this (scoping issue)\n\t transformScale: 1 / 180,\n\t\n\t // Scale and transformation inputs changed to account for central origin in\n\t // WebGL, instead of top-left origin used in Leaflet\n\t //\n\t // TODO: Cannot use this.transformScale due to scope\n\t transformation: new _utilTransformation2['default'](1 / 180, 0, -1 / 180, 0)\n\t};\n\t\n\tvar EPSG4326 = (0, _lodashAssign2['default'])({}, _CRSEarth2['default'], _EPSG4326);\n\t\n\texports['default'] = EPSG4326;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 18 */\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 * Simple equirectangular (Plate Carree) projection, used by CRS like EPSG:4326\n\t * and Simple.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/projection/Projection.LonLat.js\n\t */\n\t\n\tvar _LatLon = __webpack_require__(10);\n\t\n\tvar _LatLon2 = _interopRequireDefault(_LatLon);\n\t\n\tvar _Point = __webpack_require__(11);\n\t\n\tvar _Point2 = _interopRequireDefault(_Point);\n\t\n\tvar ProjectionLatLon = {\n\t project: function project(latlon) {\n\t return (0, _Point2['default'])(latlon.lon, latlon.lat);\n\t },\n\t\n\t unproject: function unproject(point) {\n\t return (0, _LatLon2['default'])(point.y, point.x);\n\t },\n\t\n\t // Scale factor for converting between real metres and degrees\n\t //\n\t // degrees = realMetres * pointScale\n\t // realMetres = degrees / pointScale\n\t //\n\t // See: http://stackoverflow.com/questions/639695/how-to-convert-latitude-or-longitude-to-meters\n\t // See: http://gis.stackexchange.com/questions/75528/length-of-a-degree-where-do-the-terms-in-this-formula-come-from\n\t pointScale: function pointScale(latlon) {\n\t var m1 = 111132.92;\n\t var m2 = -559.82;\n\t var m3 = 1.175;\n\t var m4 = -0.0023;\n\t var p1 = 111412.84;\n\t var p2 = -93.5;\n\t var p3 = 0.118;\n\t\n\t var rad = Math.PI / 180;\n\t var lat = latlon.lat * rad;\n\t\n\t var latlen = m1 + m2 * Math.cos(2 * lat) + m3 * Math.cos(4 * lat) + m4 * Math.cos(6 * lat);\n\t var lonlen = p1 * Math.cos(lat) + p2 * Math.cos(3 * lat) + p3 * Math.cos(5 * lat);\n\t\n\t return [1 / latlen, 1 / lonlen];\n\t },\n\t\n\t bounds: [[-180, -90], [180, 90]]\n\t};\n\t\n\texports['default'] = ProjectionLatLon;\n\tmodule.exports = exports['default'];\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\t/*\n\t * A simple CRS that can be used for flat non-Earth maps like panoramas or game\n\t * maps.\n\t *\n\t * Based on:\n\t * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.Simple.js\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _CRS = __webpack_require__(9);\n\t\n\tvar _CRS2 = _interopRequireDefault(_CRS);\n\t\n\tvar _projectionProjectionLatLon = __webpack_require__(18);\n\t\n\tvar _projectionProjectionLatLon2 = _interopRequireDefault(_projectionProjectionLatLon);\n\t\n\tvar _utilTransformation = __webpack_require__(14);\n\t\n\tvar _utilTransformation2 = _interopRequireDefault(_utilTransformation);\n\t\n\tvar _Simple = {\n\t projection: _projectionProjectionLatLon2['default'],\n\t\n\t // Straight 1:1 mapping (-1, -1 would be top-left)\n\t transformation: new _utilTransformation2['default'](1, 0, 1, 0),\n\t\n\t scale: function scale(zoom) {\n\t // If zoom is provided then return scale based on map tile zoom\n\t if (zoom) {\n\t return Math.pow(2, zoom);\n\t // Else, make no change to scale – may need to increase this or make it a\n\t // user-definable variable\n\t } else {\n\t return 1;\n\t }\n\t },\n\t\n\t zoom: function zoom(scale) {\n\t return Math.log(scale) / Math.LN2;\n\t },\n\t\n\t distance: function distance(latlon1, latlon2) {\n\t var dx = latlon2.lon - latlon1.lon;\n\t var dy = latlon2.lat - latlon1.lat;\n\t\n\t return Math.sqrt(dx * dx + dy * dy);\n\t },\n\t\n\t infinite: true\n\t};\n\t\n\tvar Simple = (0, _lodashAssign2['default'])({}, _CRS2['default'], _Simple);\n\t\n\texports['default'] = Simple;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 20 */\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 * CRS.Proj4 for any Proj4-supported CRS.\n\t */\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _CRSEarth = __webpack_require__(8);\n\t\n\tvar _CRSEarth2 = _interopRequireDefault(_CRSEarth);\n\t\n\tvar _projectionProjectionProj4 = __webpack_require__(21);\n\t\n\tvar _projectionProjectionProj42 = _interopRequireDefault(_projectionProjectionProj4);\n\t\n\tvar _utilTransformation = __webpack_require__(14);\n\t\n\tvar _utilTransformation2 = _interopRequireDefault(_utilTransformation);\n\t\n\tvar _Proj4 = function _Proj4(code, def, bounds) {\n\t var projection = (0, _projectionProjectionProj42['default'])(def, bounds);\n\t\n\t // Transformation calcuations\n\t var diffX = projection.bounds[1][0] - projection.bounds[0][0];\n\t var diffY = projection.bounds[1][1] - projection.bounds[0][1];\n\t\n\t var halfX = diffX / 2;\n\t var halfY = diffY / 2;\n\t\n\t // This is the raw scale factor\n\t var scaleX = 1 / halfX;\n\t var scaleY = 1 / halfY;\n\t\n\t // Find the minimum scale factor\n\t //\n\t // The minimum scale factor comes from the largest side and is the one\n\t // you want to use for both axis so they stay relative in dimension\n\t var scale = Math.min(scaleX, scaleY);\n\t\n\t // Find amount to offset each axis by to make the central point lie on\n\t // the [0,0] origin\n\t var offsetX = scale * (projection.bounds[0][0] + halfX);\n\t var offsetY = scale * (projection.bounds[0][1] + halfY);\n\t\n\t return {\n\t code: code,\n\t projection: projection,\n\t\n\t transformScale: scale,\n\t\n\t // Map the input to a [-1,1] range with [0,0] in the centre\n\t transformation: new _utilTransformation2['default'](scale, -offsetX, -scale, offsetY)\n\t };\n\t};\n\t\n\tvar Proj4 = function Proj4(code, def, bounds) {\n\t return (0, _lodashAssign2['default'])({}, _CRSEarth2['default'], _Proj4(code, def, bounds));\n\t};\n\t\n\texports['default'] = Proj4;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 21 */\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 * Proj4 support for any projection.\n\t */\n\t\n\tvar _proj4 = __webpack_require__(22);\n\t\n\tvar _proj42 = _interopRequireDefault(_proj4);\n\t\n\tvar _LatLon = __webpack_require__(10);\n\t\n\tvar _LatLon2 = _interopRequireDefault(_LatLon);\n\t\n\tvar _Point = __webpack_require__(11);\n\t\n\tvar _Point2 = _interopRequireDefault(_Point);\n\t\n\tvar Proj4 = function Proj4(def, bounds) {\n\t var proj = (0, _proj42['default'])(def);\n\t\n\t var project = function project(latlon) {\n\t return (0, _Point2['default'])(proj.forward([latlon.lon, latlon.lat]));\n\t };\n\t\n\t var unproject = function unproject(point) {\n\t var inverse = proj.inverse([point.x, point.y]);\n\t return (0, _LatLon2['default'])(inverse[1], inverse[0]);\n\t };\n\t\n\t return {\n\t project: project,\n\t unproject: unproject,\n\t\n\t // Scale factor for converting between real metres and projected metres\\\n\t //\n\t // Need to work out the best way to provide the pointScale calculations\n\t // for custom, unknown projections (if wanting to override default)\n\t //\n\t // For now, user can manually override crs.pointScale or\n\t // crs.projection.pointScale\n\t //\n\t // projectedMetres = realMetres * pointScale\n\t // realMetres = projectedMetres / pointScale\n\t pointScale: function pointScale(latlon, accurate) {\n\t return [1, 1];\n\t },\n\t\n\t // Try and calculate bounds if none are provided\n\t //\n\t // This will provide incorrect bounds for some projections, so perhaps make\n\t // bounds a required input instead\n\t bounds: (function () {\n\t if (bounds) {\n\t return bounds;\n\t } else {\n\t var bottomLeft = project([-90, -180]);\n\t var topRight = project([90, 180]);\n\t\n\t return [bottomLeft, topRight];\n\t }\n\t })()\n\t };\n\t};\n\t\n\texports['default'] = Proj4;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 22 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_22__;\n\n/***/ },\n/* 23 */\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__(2);\n\t\n\tvar _eventemitter32 = _interopRequireDefault(_eventemitter3);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _Scene = __webpack_require__(25);\n\t\n\tvar _Scene2 = _interopRequireDefault(_Scene);\n\t\n\tvar _Renderer = __webpack_require__(26);\n\t\n\tvar _Renderer2 = _interopRequireDefault(_Renderer);\n\t\n\tvar _Camera = __webpack_require__(27);\n\t\n\tvar _Camera2 = _interopRequireDefault(_Camera);\n\t\n\tvar Engine = (function (_EventEmitter) {\n\t _inherits(Engine, _EventEmitter);\n\t\n\t function Engine(container) {\n\t _classCallCheck(this, Engine);\n\t\n\t console.log('Init Engine');\n\t\n\t _get(Object.getPrototypeOf(Engine.prototype), 'constructor', this).call(this);\n\t\n\t this._scene = _Scene2['default'];\n\t this._renderer = (0, _Renderer2['default'])(container);\n\t this._camera = (0, _Camera2['default'])(container);\n\t this.clock = new _three2['default'].Clock();\n\t\n\t this._frustum = new _three2['default'].Frustum();\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t _createClass(Engine, [{\n\t key: 'update',\n\t value: function update(delta) {\n\t this.emit('preRender');\n\t this._renderer.render(this._scene, this._camera);\n\t this.emit('postRender');\n\t }\n\t }]);\n\t\n\t return Engine;\n\t})(_eventemitter32['default']);\n\t\n\texports['default'] = function (container) {\n\t return new Engine(container);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 24 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_24__;\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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _three = __webpack_require__(24);\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/* 26 */\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__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _Scene = __webpack_require__(25);\n\t\n\tvar _Scene2 = _interopRequireDefault(_Scene);\n\t\n\t// This can only be accessed from Engine.renderer if you want to reference the\n\t// same scene in multiple places\n\t\n\texports['default'] = function (container) {\n\t var renderer = new _three2['default'].WebGLRenderer({\n\t antialias: true\n\t });\n\t\n\t // TODO: Re-enable when this works with the skybox\n\t // renderer.setClearColor(Scene.fog.color, 1);\n\t\n\t renderer.setClearColor(0xffffff, 1);\n\t\n\t // Gamma settings make things look nicer\n\t renderer.gammaInput = true;\n\t renderer.gammaOutput = true;\n\t\n\t renderer.shadowMap.enabled = true;\n\t renderer.shadowMap.cullFace = _three2['default'].CullFaceBack;\n\t\n\t container.appendChild(renderer.domElement);\n\t\n\t var updateSize = function updateSize() {\n\t renderer.setSize(container.clientWidth, container.clientHeight);\n\t };\n\t\n\t window.addEventListener('resize', updateSize, false);\n\t updateSize();\n\t\n\t return renderer;\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 27 */\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__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t// This can only be accessed from Engine.camera if you want to reference the\n\t// same scene in multiple places\n\t\n\t// TODO: Ensure that FOV looks natural on all aspect ratios\n\t// http://stackoverflow.com/q/26655930/997339\n\t\n\texports['default'] = function (container) {\n\t var camera = new _three2['default'].PerspectiveCamera(45, 1, 1, 200000);\n\t camera.position.y = 400;\n\t camera.position.z = 400;\n\t\n\t var updateSize = function updateSize() {\n\t camera.aspect = container.clientWidth / container.clientHeight;\n\t camera.updateProjectionMatrix();\n\t };\n\t\n\t window.addEventListener('resize', updateSize, false);\n\t updateSize();\n\t\n\t return camera;\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 28 */\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 _ControlsOrbit = __webpack_require__(29);\n\t\n\tvar _ControlsOrbit2 = _interopRequireDefault(_ControlsOrbit);\n\t\n\tvar Controls = {\n\t Orbit: _ControlsOrbit2['default']\n\t};\n\t\n\texports['default'] = Controls;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 29 */\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__(2);\n\t\n\tvar _eventemitter32 = _interopRequireDefault(_eventemitter3);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _vendorOrbitControls = __webpack_require__(30);\n\t\n\tvar _vendorOrbitControls2 = _interopRequireDefault(_vendorOrbitControls);\n\t\n\tvar Orbit = (function (_EventEmitter) {\n\t _inherits(Orbit, _EventEmitter);\n\t\n\t function Orbit() {\n\t _classCallCheck(this, Orbit);\n\t\n\t _get(Object.getPrototypeOf(Orbit.prototype), 'constructor', this).call(this);\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t // Proxy control events\n\t //\n\t // There's currently no distinction between pan, orbit and zoom events\n\t\n\t _createClass(Orbit, [{\n\t key: '_initEvents',\n\t value: function _initEvents() {\n\t var _this = this;\n\t\n\t this._controls.addEventListener('start', function (event) {\n\t _this._world.emit('controlsMoveStart', event.target.target);\n\t });\n\t\n\t this._controls.addEventListener('change', function (event) {\n\t _this._world.emit('controlsMove', event.target.target);\n\t });\n\t\n\t this._controls.addEventListener('end', function (event) {\n\t _this._world.emit('controlsMoveEnd', event.target.target);\n\t });\n\t }\n\t\n\t // Moving the camera along the [x,y,z] axis based on a target position\n\t }, {\n\t key: '_panTo',\n\t value: function _panTo(point, animate) {}\n\t }, {\n\t key: '_panBy',\n\t value: function _panBy(pointDelta, animate) {}\n\t\n\t // Zooming the camera in and out\n\t }, {\n\t key: '_zoomTo',\n\t value: function _zoomTo(metres, animate) {}\n\t }, {\n\t key: '_zoomBy',\n\t value: function _zoomBy(metresDelta, animate) {}\n\t\n\t // Force camera to look at something other than the target\n\t }, {\n\t key: '_lookAt',\n\t value: function _lookAt(point, animate) {}\n\t\n\t // Make camera look at the target\n\t }, {\n\t key: '_lookAtTarget',\n\t value: function _lookAtTarget() {}\n\t\n\t // Tilt (up and down)\n\t }, {\n\t key: '_tiltTo',\n\t value: function _tiltTo(angle, animate) {}\n\t }, {\n\t key: '_tiltBy',\n\t value: function _tiltBy(angleDelta, animate) {}\n\t\n\t // Rotate (left and right)\n\t }, {\n\t key: '_rotateTo',\n\t value: function _rotateTo(angle, animate) {}\n\t }, {\n\t key: '_rotateBy',\n\t value: function _rotateBy(angleDelta, animate) {}\n\t\n\t // Fly to the given point, animating pan and tilt/rotation to final position\n\t // with nice zoom out and in\n\t //\n\t // Calling flyTo a second time before the previous animation has completed\n\t // will immediately start the new animation from wherever the previous one\n\t // has got to\n\t }, {\n\t key: '_flyTo',\n\t value: function _flyTo(point, noZoom) {}\n\t\n\t // Proxy to OrbitControls.update()\n\t }, {\n\t key: 'update',\n\t value: function update() {\n\t this._controls.update();\n\t }\n\t\n\t // Add controls to world instance and store world reference\n\t }, {\n\t key: 'addTo',\n\t value: function addTo(world) {\n\t world.addControls(this);\n\t return this;\n\t }\n\t\n\t // Internal method called by World.addControls to actually add the controls\n\t }, {\n\t key: '_addToWorld',\n\t value: function _addToWorld(world) {\n\t this._world = world;\n\t\n\t // TODO: Override panLeft and panUp methods to prevent panning on Y axis\n\t // See: http://stackoverflow.com/a/26188674/997339\n\t this._controls = new _vendorOrbitControls2['default'](world._engine._camera, world._container);\n\t\n\t // Disable keys for now as no events are fired for them anyway\n\t this._controls.keys = false;\n\t\n\t // 89 degrees\n\t this._controls.maxPolarAngle = 1.5533;\n\t\n\t // this._controls.enableDamping = true;\n\t // this._controls.dampingFactor = 0.25;\n\t\n\t this._initEvents();\n\t\n\t this.emit('added');\n\t }\n\t }]);\n\t\n\t return Orbit;\n\t})(_eventemitter32['default']);\n\t\n\texports['default'] = function () {\n\t return new Orbit();\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 30 */\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 eqeqeq:0*/\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t/**\n\t * @author qiao / https://github.com/qiao\n\t * @author mrdoob / http://mrdoob.com\n\t * @author alteredq / http://alteredqualia.com/\n\t * @author WestLangley / http://github.com/WestLangley\n\t * @author erich666 / http://erichaines.com\n\t */\n\t\n\t// This set of controls performs orbiting, dollying (zooming), and panning.\n\t// Unlike TrackballControls, it maintains the \"up\" direction object.up (+Y by default).\n\t//\n\t// Orbit - left mouse / touch: one finger move\n\t// Zoom - middle mouse, or mousewheel / touch: two finger spread or squish\n\t// Pan - right mouse, or arrow keys / touch: three finter swipe\n\t\n\tvar OrbitControls = function OrbitControls(object, domElement) {\n\t\n\t\tthis.object = object;\n\t\n\t\tthis.domElement = domElement !== undefined ? domElement : document;\n\t\n\t\t// Set to false to disable this control\n\t\tthis.enabled = true;\n\t\n\t\t// \"target\" sets the location of focus, where the object orbits around\n\t\tthis.target = new _three2['default'].Vector3();\n\t\n\t\t// How far you can dolly in and out ( PerspectiveCamera only )\n\t\tthis.minDistance = 0;\n\t\tthis.maxDistance = Infinity;\n\t\n\t\t// How far you can zoom in and out ( OrthographicCamera only )\n\t\tthis.minZoom = 0;\n\t\tthis.maxZoom = Infinity;\n\t\n\t\t// How far you can orbit vertically, upper and lower limits.\n\t\t// Range is 0 to Math.PI radians.\n\t\tthis.minPolarAngle = 0; // radians\n\t\tthis.maxPolarAngle = Math.PI; // radians\n\t\n\t\t// How far you can orbit horizontally, upper and lower limits.\n\t\t// If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].\n\t\tthis.minAzimuthAngle = -Infinity; // radians\n\t\tthis.maxAzimuthAngle = Infinity; // radians\n\t\n\t\t// Set to true to enable damping (inertia)\n\t\t// If damping is enabled, you must call controls.update() in your animation loop\n\t\tthis.enableDamping = false;\n\t\tthis.dampingFactor = 0.25;\n\t\n\t\t// This option actually enables dollying in and out; left as \"zoom\" for backwards compatibility.\n\t\t// Set to false to disable zooming\n\t\tthis.enableZoom = true;\n\t\tthis.zoomSpeed = 1.0;\n\t\n\t\t// Set to false to disable rotating\n\t\tthis.enableRotate = true;\n\t\tthis.rotateSpeed = 1.0;\n\t\n\t\t// Set to false to disable panning\n\t\tthis.enablePan = true;\n\t\tthis.keyPanSpeed = 7.0; // pixels moved per arrow key push\n\t\n\t\t// Set to true to automatically rotate around the target\n\t\t// If auto-rotate is enabled, you must call controls.update() in your animation loop\n\t\tthis.autoRotate = false;\n\t\tthis.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60\n\t\n\t\t// Set to false to disable use of the keys\n\t\tthis.enableKeys = true;\n\t\n\t\t// The four arrow keys\n\t\tthis.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };\n\t\n\t\t// Mouse buttons\n\t\tthis.mouseButtons = { ORBIT: _three2['default'].MOUSE.LEFT, ZOOM: _three2['default'].MOUSE.MIDDLE, PAN: _three2['default'].MOUSE.RIGHT };\n\t\n\t\t// for reset\n\t\tthis.target0 = this.target.clone();\n\t\tthis.position0 = this.object.position.clone();\n\t\tthis.zoom0 = this.object.zoom;\n\t\n\t\t//\n\t\t// public methods\n\t\t//\n\t\n\t\tthis.getPolarAngle = function () {\n\t\n\t\t\treturn phi;\n\t\t};\n\t\n\t\tthis.getAzimuthalAngle = function () {\n\t\n\t\t\treturn theta;\n\t\t};\n\t\n\t\tthis.reset = function () {\n\t\n\t\t\tscope.target.copy(scope.target0);\n\t\t\tscope.object.position.copy(scope.position0);\n\t\t\tscope.object.zoom = scope.zoom0;\n\t\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tscope.dispatchEvent(changeEvent);\n\t\n\t\t\tscope.update();\n\t\n\t\t\tstate = STATE.NONE;\n\t\t};\n\t\n\t\t// this method is exposed, but perhaps it would be better if we can make it private...\n\t\tthis.update = (function () {\n\t\n\t\t\tvar offset = new _three2['default'].Vector3();\n\t\n\t\t\t// so camera.up is the orbit axis\n\t\t\tvar quat = new _three2['default'].Quaternion().setFromUnitVectors(object.up, new _three2['default'].Vector3(0, 1, 0));\n\t\t\tvar quatInverse = quat.clone().inverse();\n\t\n\t\t\tvar lastPosition = new _three2['default'].Vector3();\n\t\t\tvar lastQuaternion = new _three2['default'].Quaternion();\n\t\n\t\t\treturn function () {\n\t\n\t\t\t\tvar position = scope.object.position;\n\t\n\t\t\t\toffset.copy(position).sub(scope.target);\n\t\n\t\t\t\t// rotate offset to \"y-axis-is-up\" space\n\t\t\t\toffset.applyQuaternion(quat);\n\t\n\t\t\t\t// angle from z-axis around y-axis\n\t\n\t\t\t\ttheta = Math.atan2(offset.x, offset.z);\n\t\n\t\t\t\t// angle from y-axis\n\t\n\t\t\t\tphi = Math.atan2(Math.sqrt(offset.x * offset.x + offset.z * offset.z), offset.y);\n\t\n\t\t\t\tif (scope.autoRotate && state === STATE.NONE) {\n\t\n\t\t\t\t\trotateLeft(getAutoRotationAngle());\n\t\t\t\t}\n\t\n\t\t\t\ttheta += thetaDelta;\n\t\t\t\tphi += phiDelta;\n\t\n\t\t\t\t// restrict theta to be between desired limits\n\t\t\t\ttheta = Math.max(scope.minAzimuthAngle, Math.min(scope.maxAzimuthAngle, theta));\n\t\n\t\t\t\t// restrict phi to be between desired limits\n\t\t\t\tphi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, phi));\n\t\n\t\t\t\t// restrict phi to be betwee EPS and PI-EPS\n\t\t\t\tphi = Math.max(EPS, Math.min(Math.PI - EPS, phi));\n\t\n\t\t\t\tvar radius = offset.length() * scale;\n\t\n\t\t\t\t// restrict radius to be between desired limits\n\t\t\t\tradius = Math.max(scope.minDistance, Math.min(scope.maxDistance, radius));\n\t\n\t\t\t\t// move target to panned location\n\t\t\t\tscope.target.add(panOffset);\n\t\n\t\t\t\toffset.x = radius * Math.sin(phi) * Math.sin(theta);\n\t\t\t\toffset.y = radius * Math.cos(phi);\n\t\t\t\toffset.z = radius * Math.sin(phi) * Math.cos(theta);\n\t\n\t\t\t\t// rotate offset back to \"camera-up-vector-is-up\" space\n\t\t\t\toffset.applyQuaternion(quatInverse);\n\t\n\t\t\t\tposition.copy(scope.target).add(offset);\n\t\n\t\t\t\tscope.object.lookAt(scope.target);\n\t\n\t\t\t\tif (scope.enableDamping === true) {\n\t\n\t\t\t\t\tthetaDelta *= 1 - scope.dampingFactor;\n\t\t\t\t\tphiDelta *= 1 - scope.dampingFactor;\n\t\t\t\t} else {\n\t\n\t\t\t\t\tthetaDelta = 0;\n\t\t\t\t\tphiDelta = 0;\n\t\t\t\t}\n\t\n\t\t\t\tscale = 1;\n\t\t\t\tpanOffset.set(0, 0, 0);\n\t\n\t\t\t\t// update condition is:\n\t\t\t\t// min(camera displacement, camera rotation in radians)^2 > EPS\n\t\t\t\t// using small-angle approximation cos(x/2) = 1 - x^2 / 8\n\t\n\t\t\t\tif (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {\n\t\n\t\t\t\t\tscope.dispatchEvent(changeEvent);\n\t\n\t\t\t\t\tlastPosition.copy(scope.object.position);\n\t\t\t\t\tlastQuaternion.copy(scope.object.quaternion);\n\t\t\t\t\tzoomChanged = false;\n\t\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\n\t\t\t\treturn false;\n\t\t\t};\n\t\t})();\n\t\n\t\tthis.dispose = function () {\n\t\n\t\t\tscope.domElement.removeEventListener('contextmenu', onContextMenu, false);\n\t\t\tscope.domElement.removeEventListener('mousedown', onMouseDown, false);\n\t\t\tscope.domElement.removeEventListener('mousewheel', onMouseWheel, false);\n\t\t\tscope.domElement.removeEventListener('MozMousePixelScroll', onMouseWheel, false); // firefox\n\t\n\t\t\tscope.domElement.removeEventListener('touchstart', onTouchStart, false);\n\t\t\tscope.domElement.removeEventListener('touchend', onTouchEnd, false);\n\t\t\tscope.domElement.removeEventListener('touchmove', onTouchMove, false);\n\t\n\t\t\tdocument.removeEventListener('mousemove', onMouseMove, false);\n\t\t\tdocument.removeEventListener('mouseup', onMouseUp, false);\n\t\t\tdocument.removeEventListener('mouseout', onMouseUp, false);\n\t\n\t\t\twindow.removeEventListener('keydown', onKeyDown, false);\n\t\n\t\t\t//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?\n\t\t};\n\t\n\t\t//\n\t\t// internals\n\t\t//\n\t\n\t\tvar scope = this;\n\t\n\t\tvar changeEvent = { type: 'change' };\n\t\tvar startEvent = { type: 'start' };\n\t\tvar endEvent = { type: 'end' };\n\t\n\t\tvar STATE = { NONE: -1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_DOLLY: 4, TOUCH_PAN: 5 };\n\t\n\t\tvar state = STATE.NONE;\n\t\n\t\tvar EPS = 0.000001;\n\t\n\t\t// current position in spherical coordinates\n\t\tvar theta;\n\t\tvar phi;\n\t\n\t\tvar phiDelta = 0;\n\t\tvar thetaDelta = 0;\n\t\tvar scale = 1;\n\t\tvar panOffset = new _three2['default'].Vector3();\n\t\tvar zoomChanged = false;\n\t\n\t\tvar rotateStart = new _three2['default'].Vector2();\n\t\tvar rotateEnd = new _three2['default'].Vector2();\n\t\tvar rotateDelta = new _three2['default'].Vector2();\n\t\n\t\tvar panStart = new _three2['default'].Vector2();\n\t\tvar panEnd = new _three2['default'].Vector2();\n\t\tvar panDelta = new _three2['default'].Vector2();\n\t\n\t\tvar dollyStart = new _three2['default'].Vector2();\n\t\tvar dollyEnd = new _three2['default'].Vector2();\n\t\tvar dollyDelta = new _three2['default'].Vector2();\n\t\n\t\tfunction getAutoRotationAngle() {\n\t\n\t\t\treturn 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;\n\t\t}\n\t\n\t\tfunction getZoomScale() {\n\t\n\t\t\treturn Math.pow(0.95, scope.zoomSpeed);\n\t\t}\n\t\n\t\tfunction rotateLeft(angle) {\n\t\n\t\t\tthetaDelta -= angle;\n\t\t}\n\t\n\t\tfunction rotateUp(angle) {\n\t\n\t\t\tphiDelta -= angle;\n\t\t}\n\t\n\t\tvar panLeft = (function () {\n\t\n\t\t\tvar v = new _three2['default'].Vector3();\n\t\n\t\t\t// return function panLeft( distance, objectMatrix ) {\n\t\t\t//\n\t\t\t// \tvar te = objectMatrix.elements;\n\t\t\t//\n\t\t\t// \t// get X column of objectMatrix\n\t\t\t// \tv.set( te[ 0 ], te[ 1 ], te[ 2 ] );\n\t\t\t//\n\t\t\t// \tv.multiplyScalar( - distance );\n\t\t\t//\n\t\t\t// \tpanOffset.add( v );\n\t\t\t//\n\t\t\t// };\n\t\n\t\t\t// Fixed panning to x/y plane\n\t\t\treturn function panLeft(distance, objectMatrix) {\n\t\t\t\tvar te = objectMatrix.elements;\n\t\t\t\t// var adjDist = distance / Math.cos(phi);\n\t\n\t\t\t\tv.set(te[0], 0, te[2]);\n\t\t\t\tv.multiplyScalar(-distance);\n\t\n\t\t\t\tpanOffset.add(v);\n\t\t\t};\n\t\t})();\n\t\n\t\t// Fixed panning to x/y plane\n\t\tvar panUp = (function () {\n\t\n\t\t\tvar v = new _three2['default'].Vector3();\n\t\n\t\t\t// return function panUp( distance, objectMatrix ) {\n\t\t\t//\n\t\t\t// \tvar te = objectMatrix.elements;\n\t\t\t//\n\t\t\t// \t// get Y column of objectMatrix\n\t\t\t// \tv.set( te[ 4 ], te[ 5 ], te[ 6 ] );\n\t\t\t//\n\t\t\t// \tv.multiplyScalar( distance );\n\t\t\t//\n\t\t\t// \tpanOffset.add( v );\n\t\t\t//\n\t\t\t// };\n\t\n\t\t\treturn function panUp(distance, objectMatrix) {\n\t\t\t\tvar te = objectMatrix.elements;\n\t\t\t\tvar adjDist = distance / Math.cos(phi);\n\t\n\t\t\t\tv.set(te[4], 0, te[6]);\n\t\t\t\tv.multiplyScalar(adjDist);\n\t\n\t\t\t\tpanOffset.add(v);\n\t\t\t};\n\t\t})();\n\t\n\t\t// deltaX and deltaY are in pixels; right and down are positive\n\t\tvar pan = (function () {\n\t\n\t\t\tvar offset = new _three2['default'].Vector3();\n\t\n\t\t\treturn function (deltaX, deltaY) {\n\t\n\t\t\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\t\n\t\t\t\tif (scope.object instanceof _three2['default'].PerspectiveCamera) {\n\t\n\t\t\t\t\t// perspective\n\t\t\t\t\tvar position = scope.object.position;\n\t\t\t\t\toffset.copy(position).sub(scope.target);\n\t\t\t\t\tvar targetDistance = offset.length();\n\t\n\t\t\t\t\t// half of the fov is center to top of screen\n\t\t\t\t\ttargetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180.0);\n\t\n\t\t\t\t\t// we actually don't use screenWidth, since perspective camera is fixed to screen height\n\t\t\t\t\tpanLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);\n\t\t\t\t\tpanUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);\n\t\t\t\t} else if (scope.object instanceof _three2['default'].OrthographicCamera) {\n\t\n\t\t\t\t\t// orthographic\n\t\t\t\t\tpanLeft(deltaX * (scope.object.right - scope.object.left) / element.clientWidth, scope.object.matrix);\n\t\t\t\t\tpanUp(deltaY * (scope.object.top - scope.object.bottom) / element.clientHeight, scope.object.matrix);\n\t\t\t\t} else {\n\t\n\t\t\t\t\t// camera neither orthographic nor perspective\n\t\t\t\t\tconsole.warn('WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.');\n\t\t\t\t\tscope.enablePan = false;\n\t\t\t\t}\n\t\t\t};\n\t\t})();\n\t\n\t\tfunction dollyIn(dollyScale) {\n\t\n\t\t\tif (scope.object instanceof _three2['default'].PerspectiveCamera) {\n\t\n\t\t\t\tscale /= dollyScale;\n\t\t\t} else if (scope.object instanceof _three2['default'].OrthographicCamera) {\n\t\n\t\t\t\tscope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));\n\t\t\t\tscope.object.updateProjectionMatrix();\n\t\t\t\tzoomChanged = true;\n\t\t\t} else {\n\t\n\t\t\t\tconsole.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.');\n\t\t\t\tscope.enableZoom = false;\n\t\t\t}\n\t\t}\n\t\n\t\tfunction dollyOut(dollyScale) {\n\t\n\t\t\tif (scope.object instanceof _three2['default'].PerspectiveCamera) {\n\t\n\t\t\t\tscale *= dollyScale;\n\t\t\t} else if (scope.object instanceof _three2['default'].OrthographicCamera) {\n\t\n\t\t\t\tscope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));\n\t\t\t\tscope.object.updateProjectionMatrix();\n\t\t\t\tzoomChanged = true;\n\t\t\t} else {\n\t\n\t\t\t\tconsole.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.');\n\t\t\t\tscope.enableZoom = false;\n\t\t\t}\n\t\t}\n\t\n\t\t//\n\t\t// event callbacks - update the object state\n\t\t//\n\t\n\t\tfunction handleMouseDownRotate(event) {\n\t\n\t\t\t//console.log( 'handleMouseDownRotate' );\n\t\n\t\t\trotateStart.set(event.clientX, event.clientY);\n\t\t}\n\t\n\t\tfunction handleMouseDownDolly(event) {\n\t\n\t\t\t//console.log( 'handleMouseDownDolly' );\n\t\n\t\t\tdollyStart.set(event.clientX, event.clientY);\n\t\t}\n\t\n\t\tfunction handleMouseDownPan(event) {\n\t\n\t\t\t//console.log( 'handleMouseDownPan' );\n\t\n\t\t\tpanStart.set(event.clientX, event.clientY);\n\t\t}\n\t\n\t\tfunction handleMouseMoveRotate(event) {\n\t\n\t\t\t//console.log( 'handleMouseMoveRotate' );\n\t\n\t\t\trotateEnd.set(event.clientX, event.clientY);\n\t\t\trotateDelta.subVectors(rotateEnd, rotateStart);\n\t\n\t\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\t\n\t\t\t// rotating across whole screen goes 360 degrees around\n\t\t\trotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed);\n\t\n\t\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\t\trotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed);\n\t\n\t\t\trotateStart.copy(rotateEnd);\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleMouseMoveDolly(event) {\n\t\n\t\t\t//console.log( 'handleMouseMoveDolly' );\n\t\n\t\t\tdollyEnd.set(event.clientX, event.clientY);\n\t\n\t\t\tdollyDelta.subVectors(dollyEnd, dollyStart);\n\t\n\t\t\tif (dollyDelta.y > 0) {\n\t\n\t\t\t\tdollyIn(getZoomScale());\n\t\t\t} else if (dollyDelta.y < 0) {\n\t\n\t\t\t\tdollyOut(getZoomScale());\n\t\t\t}\n\t\n\t\t\tdollyStart.copy(dollyEnd);\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleMouseMovePan(event) {\n\t\n\t\t\t//console.log( 'handleMouseMovePan' );\n\t\n\t\t\tpanEnd.set(event.clientX, event.clientY);\n\t\n\t\t\tpanDelta.subVectors(panEnd, panStart);\n\t\n\t\t\tpan(panDelta.x, panDelta.y);\n\t\n\t\t\tpanStart.copy(panEnd);\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleMouseUp(event) {\n\t\n\t\t\t//console.log( 'handleMouseUp' );\n\t\n\t\t}\n\t\n\t\tfunction handleMouseWheel(event) {\n\t\n\t\t\t//console.log( 'handleMouseWheel' );\n\t\n\t\t\tvar delta = 0;\n\t\n\t\t\tif (event.wheelDelta !== undefined) {\n\t\n\t\t\t\t// WebKit / Opera / Explorer 9\n\t\n\t\t\t\tdelta = event.wheelDelta;\n\t\t\t} else if (event.detail !== undefined) {\n\t\n\t\t\t\t// Firefox\n\t\n\t\t\t\tdelta = -event.detail;\n\t\t\t}\n\t\n\t\t\tif (delta > 0) {\n\t\n\t\t\t\tdollyOut(getZoomScale());\n\t\t\t} else if (delta < 0) {\n\t\n\t\t\t\tdollyIn(getZoomScale());\n\t\t\t}\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleKeyDown(event) {\n\t\n\t\t\t//console.log( 'handleKeyDown' );\n\t\n\t\t\tswitch (event.keyCode) {\n\t\n\t\t\t\tcase scope.keys.UP:\n\t\t\t\t\tpan(0, scope.keyPanSpeed);\n\t\t\t\t\tscope.update();\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase scope.keys.BOTTOM:\n\t\t\t\t\tpan(0, -scope.keyPanSpeed);\n\t\t\t\t\tscope.update();\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase scope.keys.LEFT:\n\t\t\t\t\tpan(scope.keyPanSpeed, 0);\n\t\t\t\t\tscope.update();\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase scope.keys.RIGHT:\n\t\t\t\t\tpan(-scope.keyPanSpeed, 0);\n\t\t\t\t\tscope.update();\n\t\t\t\t\tbreak;\n\t\n\t\t\t}\n\t\t}\n\t\n\t\tfunction handleTouchStartRotate(event) {\n\t\n\t\t\t//console.log( 'handleTouchStartRotate' );\n\t\n\t\t\trotateStart.set(event.touches[0].pageX, event.touches[0].pageY);\n\t\t}\n\t\n\t\tfunction handleTouchStartDolly(event) {\n\t\n\t\t\t//console.log( 'handleTouchStartDolly' );\n\t\n\t\t\tvar dx = event.touches[0].pageX - event.touches[1].pageX;\n\t\t\tvar dy = event.touches[0].pageY - event.touches[1].pageY;\n\t\n\t\t\tvar distance = Math.sqrt(dx * dx + dy * dy);\n\t\n\t\t\tdollyStart.set(0, distance);\n\t\t}\n\t\n\t\tfunction handleTouchStartPan(event) {\n\t\n\t\t\t//console.log( 'handleTouchStartPan' );\n\t\n\t\t\tpanStart.set(event.touches[0].pageX, event.touches[0].pageY);\n\t\t}\n\t\n\t\tfunction handleTouchMoveRotate(event) {\n\t\n\t\t\t//console.log( 'handleTouchMoveRotate' );\n\t\n\t\t\trotateEnd.set(event.touches[0].pageX, event.touches[0].pageY);\n\t\t\trotateDelta.subVectors(rotateEnd, rotateStart);\n\t\n\t\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\t\n\t\t\t// rotating across whole screen goes 360 degrees around\n\t\t\trotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed);\n\t\n\t\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\t\trotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed);\n\t\n\t\t\trotateStart.copy(rotateEnd);\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleTouchMoveDolly(event) {\n\t\n\t\t\t//console.log( 'handleTouchMoveDolly' );\n\t\n\t\t\tvar dx = event.touches[0].pageX - event.touches[1].pageX;\n\t\t\tvar dy = event.touches[0].pageY - event.touches[1].pageY;\n\t\n\t\t\tvar distance = Math.sqrt(dx * dx + dy * dy);\n\t\n\t\t\tdollyEnd.set(0, distance);\n\t\n\t\t\tdollyDelta.subVectors(dollyEnd, dollyStart);\n\t\n\t\t\tif (dollyDelta.y > 0) {\n\t\n\t\t\t\tdollyOut(getZoomScale());\n\t\t\t} else if (dollyDelta.y < 0) {\n\t\n\t\t\t\tdollyIn(getZoomScale());\n\t\t\t}\n\t\n\t\t\tdollyStart.copy(dollyEnd);\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleTouchMovePan(event) {\n\t\n\t\t\t//console.log( 'handleTouchMovePan' );\n\t\n\t\t\tpanEnd.set(event.touches[0].pageX, event.touches[0].pageY);\n\t\n\t\t\tpanDelta.subVectors(panEnd, panStart);\n\t\n\t\t\tpan(panDelta.x, panDelta.y);\n\t\n\t\t\tpanStart.copy(panEnd);\n\t\n\t\t\tscope.update();\n\t\t}\n\t\n\t\tfunction handleTouchEnd(event) {}\n\t\n\t\t//console.log( 'handleTouchEnd' );\n\t\n\t\t//\n\t\t// event handlers - FSM: listen for events and reset state\n\t\t//\n\t\n\t\tfunction onMouseDown(event) {\n\t\n\t\t\tif (scope.enabled === false) return;\n\t\n\t\t\tevent.preventDefault();\n\t\n\t\t\tif (event.button === scope.mouseButtons.ORBIT) {\n\t\n\t\t\t\tif (scope.enableRotate === false) return;\n\t\n\t\t\t\thandleMouseDownRotate(event);\n\t\n\t\t\t\tstate = STATE.ROTATE;\n\t\t\t} else if (event.button === scope.mouseButtons.ZOOM) {\n\t\n\t\t\t\tif (scope.enableZoom === false) return;\n\t\n\t\t\t\thandleMouseDownDolly(event);\n\t\n\t\t\t\tstate = STATE.DOLLY;\n\t\t\t} else if (event.button === scope.mouseButtons.PAN) {\n\t\n\t\t\t\tif (scope.enablePan === false) return;\n\t\n\t\t\t\thandleMouseDownPan(event);\n\t\n\t\t\t\tstate = STATE.PAN;\n\t\t\t}\n\t\n\t\t\tif (state !== STATE.NONE) {\n\t\n\t\t\t\tdocument.addEventListener('mousemove', onMouseMove, false);\n\t\t\t\tdocument.addEventListener('mouseup', onMouseUp, false);\n\t\t\t\tdocument.addEventListener('mouseout', onMouseUp, false);\n\t\n\t\t\t\tscope.dispatchEvent(startEvent);\n\t\t\t}\n\t\t}\n\t\n\t\tfunction onMouseMove(event) {\n\t\n\t\t\tif (scope.enabled === false) return;\n\t\n\t\t\tevent.preventDefault();\n\t\n\t\t\tif (state === STATE.ROTATE) {\n\t\n\t\t\t\tif (scope.enableRotate === false) return;\n\t\n\t\t\t\thandleMouseMoveRotate(event);\n\t\t\t} else if (state === STATE.DOLLY) {\n\t\n\t\t\t\tif (scope.enableZoom === false) return;\n\t\n\t\t\t\thandleMouseMoveDolly(event);\n\t\t\t} else if (state === STATE.PAN) {\n\t\n\t\t\t\tif (scope.enablePan === false) return;\n\t\n\t\t\t\thandleMouseMovePan(event);\n\t\t\t}\n\t\t}\n\t\n\t\tfunction onMouseUp(event) {\n\t\n\t\t\tif (scope.enabled === false) return;\n\t\n\t\t\thandleMouseUp(event);\n\t\n\t\t\tdocument.removeEventListener('mousemove', onMouseMove, false);\n\t\t\tdocument.removeEventListener('mouseup', onMouseUp, false);\n\t\t\tdocument.removeEventListener('mouseout', onMouseUp, false);\n\t\n\t\t\tscope.dispatchEvent(endEvent);\n\t\n\t\t\tstate = STATE.NONE;\n\t\t}\n\t\n\t\tfunction onMouseWheel(event) {\n\t\n\t\t\tif (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;\n\t\n\t\t\tevent.preventDefault();\n\t\t\tevent.stopPropagation();\n\t\n\t\t\thandleMouseWheel(event);\n\t\n\t\t\tscope.dispatchEvent(startEvent); // not sure why these are here...\n\t\t\tscope.dispatchEvent(endEvent);\n\t\t}\n\t\n\t\tfunction onKeyDown(event) {\n\t\n\t\t\tif (scope.enabled === false || scope.enableKeys === false || scope.enablePan === false) return;\n\t\n\t\t\thandleKeyDown(event);\n\t\t}\n\t\n\t\tfunction onTouchStart(event) {\n\t\n\t\t\tif (scope.enabled === false) return;\n\t\n\t\t\tswitch (event.touches.length) {\n\t\n\t\t\t\tcase 1:\n\t\t\t\t\t// one-fingered touch: rotate\n\t\n\t\t\t\t\tif (scope.enableRotate === false) return;\n\t\n\t\t\t\t\thandleTouchStartRotate(event);\n\t\n\t\t\t\t\tstate = STATE.TOUCH_ROTATE;\n\t\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase 2:\n\t\t\t\t\t// two-fingered touch: dolly\n\t\n\t\t\t\t\tif (scope.enableZoom === false) return;\n\t\n\t\t\t\t\thandleTouchStartDolly(event);\n\t\n\t\t\t\t\tstate = STATE.TOUCH_DOLLY;\n\t\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase 3:\n\t\t\t\t\t// three-fingered touch: pan\n\t\n\t\t\t\t\tif (scope.enablePan === false) return;\n\t\n\t\t\t\t\thandleTouchStartPan(event);\n\t\n\t\t\t\t\tstate = STATE.TOUCH_PAN;\n\t\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tdefault:\n\t\n\t\t\t\t\tstate = STATE.NONE;\n\t\n\t\t\t}\n\t\n\t\t\tif (state !== STATE.NONE) {\n\t\n\t\t\t\tscope.dispatchEvent(startEvent);\n\t\t\t}\n\t\t}\n\t\n\t\tfunction onTouchMove(event) {\n\t\n\t\t\tif (scope.enabled === false) return;\n\t\n\t\t\tevent.preventDefault();\n\t\t\tevent.stopPropagation();\n\t\n\t\t\tswitch (event.touches.length) {\n\t\n\t\t\t\tcase 1:\n\t\t\t\t\t// one-fingered touch: rotate\n\t\n\t\t\t\t\tif (scope.enableRotate === false) return;\n\t\t\t\t\tif (state !== STATE.TOUCH_ROTATE) return; // is this needed?...\n\t\n\t\t\t\t\thandleTouchMoveRotate(event);\n\t\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase 2:\n\t\t\t\t\t// two-fingered touch: dolly\n\t\n\t\t\t\t\tif (scope.enableZoom === false) return;\n\t\t\t\t\tif (state !== STATE.TOUCH_DOLLY) return; // is this needed?...\n\t\n\t\t\t\t\thandleTouchMoveDolly(event);\n\t\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tcase 3:\n\t\t\t\t\t// three-fingered touch: pan\n\t\n\t\t\t\t\tif (scope.enablePan === false) return;\n\t\t\t\t\tif (state !== STATE.TOUCH_PAN) return; // is this needed?...\n\t\n\t\t\t\t\thandleTouchMovePan(event);\n\t\n\t\t\t\t\tbreak;\n\t\n\t\t\t\tdefault:\n\t\n\t\t\t\t\tstate = STATE.NONE;\n\t\n\t\t\t}\n\t\t}\n\t\n\t\tfunction onTouchEnd(event) {\n\t\n\t\t\tif (scope.enabled === false) return;\n\t\n\t\t\thandleTouchEnd(event);\n\t\n\t\t\tscope.dispatchEvent(endEvent);\n\t\n\t\t\tstate = STATE.NONE;\n\t\t}\n\t\n\t\tfunction onContextMenu(event) {\n\t\n\t\t\tevent.preventDefault();\n\t\t}\n\t\n\t\t//\n\t\n\t\tscope.domElement.addEventListener('contextmenu', onContextMenu, false);\n\t\n\t\tscope.domElement.addEventListener('mousedown', onMouseDown, false);\n\t\tscope.domElement.addEventListener('mousewheel', onMouseWheel, false);\n\t\tscope.domElement.addEventListener('MozMousePixelScroll', onMouseWheel, false); // firefox\n\t\n\t\tscope.domElement.addEventListener('touchstart', onTouchStart, false);\n\t\tscope.domElement.addEventListener('touchend', onTouchEnd, false);\n\t\tscope.domElement.addEventListener('touchmove', onTouchMove, false);\n\t\n\t\twindow.addEventListener('keydown', onKeyDown, false);\n\t\n\t\t// force an update at start\n\t\n\t\tthis.update();\n\t};\n\t\n\tOrbitControls.prototype = Object.create(_three2['default'].EventDispatcher.prototype);\n\tOrbitControls.prototype.constructor = _three2['default'].OrbitControls;\n\t\n\tObject.defineProperties(OrbitControls.prototype, {\n\t\n\t\tcenter: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .center has been renamed to .target');\n\t\t\t\treturn this.target;\n\t\t\t}\n\t\n\t\t},\n\t\n\t\t// backward compatibility\n\t\n\t\tnoZoom: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.');\n\t\t\t\treturn !this.enableZoom;\n\t\t\t},\n\t\n\t\t\tset: function set(value) {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.');\n\t\t\t\tthis.enableZoom = !value;\n\t\t\t}\n\t\n\t\t},\n\t\n\t\tnoRotate: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.');\n\t\t\t\treturn !this.enableRotate;\n\t\t\t},\n\t\n\t\t\tset: function set(value) {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.');\n\t\t\t\tthis.enableRotate = !value;\n\t\t\t}\n\t\n\t\t},\n\t\n\t\tnoPan: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noPan has been deprecated. Use .enablePan instead.');\n\t\t\t\treturn !this.enablePan;\n\t\t\t},\n\t\n\t\t\tset: function set(value) {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noPan has been deprecated. Use .enablePan instead.');\n\t\t\t\tthis.enablePan = !value;\n\t\t\t}\n\t\n\t\t},\n\t\n\t\tnoKeys: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.');\n\t\t\t\treturn !this.enableKeys;\n\t\t\t},\n\t\n\t\t\tset: function set(value) {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.');\n\t\t\t\tthis.enableKeys = !value;\n\t\t\t}\n\t\n\t\t},\n\t\n\t\tstaticMoving: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.');\n\t\t\t\treturn !this.constraint.enableDamping;\n\t\t\t},\n\t\n\t\t\tset: function set(value) {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.');\n\t\t\t\tthis.constraint.enableDamping = !value;\n\t\t\t}\n\t\n\t\t},\n\t\n\t\tdynamicDampingFactor: {\n\t\n\t\t\tget: function get() {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.');\n\t\t\t\treturn this.constraint.dampingFactor;\n\t\t\t},\n\t\n\t\t\tset: function set(value) {\n\t\n\t\t\t\tconsole.warn('THREE.OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.');\n\t\t\t\tthis.constraint.dampingFactor = value;\n\t\t\t}\n\t\n\t\t}\n\t\n\t});\n\t\n\texports['default'] = OrbitControls;\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\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__(32);\n\t\n\tvar _Layer3 = _interopRequireDefault(_Layer2);\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _Skybox = __webpack_require__(33);\n\t\n\tvar _Skybox2 = _interopRequireDefault(_Skybox);\n\t\n\tvar EnvironmentLayer = (function (_Layer) {\n\t _inherits(EnvironmentLayer, _Layer);\n\t\n\t function EnvironmentLayer(options) {\n\t _classCallCheck(this, EnvironmentLayer);\n\t\n\t _get(Object.getPrototypeOf(EnvironmentLayer.prototype), 'constructor', this).call(this);\n\t\n\t var defaults = {\n\t skybox: false\n\t };\n\t\n\t this._options = (0, _lodashAssign2['default'])(defaults, options);\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t _createClass(EnvironmentLayer, [{\n\t key: '_onAdd',\n\t value: function _onAdd() {\n\t this._initLights();\n\t\n\t if (this._options.skybox) {\n\t this._initSkybox();\n\t }\n\t\n\t // this._initGrid();\n\t }\n\t\n\t // Not fleshed out or thought through yet\n\t //\n\t // Lights could potentially be put it their own 'layer' to keep this class\n\t // much simpler and less messy\n\t }, {\n\t key: '_initLights',\n\t value: function _initLights() {\n\t // Position doesn't really matter (the angle is important), however it's\n\t // used here so the helpers look more natural.\n\t\n\t if (!this._options.skybox) {\n\t var directionalLight = new _three2['default'].DirectionalLight(0x999999);\n\t directionalLight.intesity = 0.1;\n\t directionalLight.position.x = 100;\n\t directionalLight.position.y = 100;\n\t directionalLight.position.z = 100;\n\t\n\t var directionalLight2 = new _three2['default'].DirectionalLight(0x999999);\n\t directionalLight2.intesity = 0.1;\n\t directionalLight2.position.x = -100;\n\t directionalLight2.position.y = 100;\n\t directionalLight2.position.z = -100;\n\t\n\t var helper = new _three2['default'].DirectionalLightHelper(directionalLight, 10);\n\t var helper2 = new _three2['default'].DirectionalLightHelper(directionalLight2, 10);\n\t\n\t this.add(directionalLight);\n\t this.add(directionalLight2);\n\t\n\t this.add(helper);\n\t this.add(helper2);\n\t } else {\n\t // Directional light that will be projected from the sun\n\t this._skyboxLight = new _three2['default'].DirectionalLight(0xffffff, 1);\n\t\n\t this._skyboxLight.castShadow = true;\n\t\n\t var d = 1000;\n\t this._skyboxLight.shadow.camera.left = -d;\n\t this._skyboxLight.shadow.camera.right = d;\n\t this._skyboxLight.shadow.camera.top = d;\n\t this._skyboxLight.shadow.camera.bottom = -d;\n\t\n\t this._skyboxLight.shadow.camera.near = 10000;\n\t this._skyboxLight.shadow.camera.far = 70000;\n\t\n\t // TODO: Need to dial in on a good shadowmap size\n\t this._skyboxLight.shadow.mapSize.width = 2048;\n\t this._skyboxLight.shadow.mapSize.height = 2048;\n\t\n\t // this._skyboxLight.shadowBias = -0.0010;\n\t // this._skyboxLight.shadow.darkness = 0.15;\n\t\n\t // this._layer.add(new THREE.CameraHelper(this._skyboxLight.shadow.camera));\n\t\n\t this.add(this._skyboxLight);\n\t }\n\t }\n\t }, {\n\t key: '_initSkybox',\n\t value: function _initSkybox() {\n\t this._skybox = (0, _Skybox2['default'])(this._world, this._skyboxLight);\n\t this.add(this._skybox._mesh);\n\t }\n\t\n\t // Add grid helper for context during initial development\n\t }, {\n\t key: '_initGrid',\n\t value: function _initGrid() {\n\t var size = 4000;\n\t var step = 100;\n\t\n\t var gridHelper = new _three2['default'].GridHelper(size, step);\n\t this.add(gridHelper);\n\t }\n\t\n\t // Clean up environment\n\t }, {\n\t key: 'destroy',\n\t value: function destroy() {\n\t this._skyboxLight = null;\n\t\n\t this.remove(this._skybox._mesh);\n\t this._skybox.destroy();\n\t this._skybox = null;\n\t\n\t _get(Object.getPrototypeOf(EnvironmentLayer.prototype), 'destroy', this).call(this);\n\t }\n\t }]);\n\t\n\t return EnvironmentLayer;\n\t})(_Layer3['default']);\n\t\n\texports['default'] = function (options) {\n\t return new EnvironmentLayer(options);\n\t};\n\t\n\t;\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\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__(2);\n\t\n\tvar _eventemitter32 = _interopRequireDefault(_eventemitter3);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _engineScene = __webpack_require__(25);\n\t\n\tvar _engineScene2 = _interopRequireDefault(_engineScene);\n\t\n\tvar Layer = (function (_EventEmitter) {\n\t _inherits(Layer, _EventEmitter);\n\t\n\t function Layer() {\n\t _classCallCheck(this, Layer);\n\t\n\t _get(Object.getPrototypeOf(Layer.prototype), 'constructor', this).call(this);\n\t\n\t this._layer = new _three2['default'].Object3D();\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._layer.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._layer.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 world.addLayer(this);\n\t return 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 this._world = world;\n\t this._onAdd(world);\n\t this.emit('added');\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 // Remove everything else in the layer\n\t var child;\n\t for (i = this._layer.children.length - 1; i >= 0; i--) {\n\t child = this._layer.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 this._world = null;\n\t this._layer = null;\n\t }\n\t }]);\n\t\n\t return Layer;\n\t})(_eventemitter32['default']);\n\t\n\texports['default'] = Layer;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 33 */\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 _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _Sky = __webpack_require__(34);\n\t\n\tvar _Sky2 = _interopRequireDefault(_Sky);\n\t\n\tvar _lodashThrottle = __webpack_require__(35);\n\t\n\tvar _lodashThrottle2 = _interopRequireDefault(_lodashThrottle);\n\t\n\tvar cubemap = {\n\t vertexShader: ['varying vec3 vPosition;', 'void main() {', 'vPosition = position;', 'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\\n'),\n\t\n\t fragmentShader: ['uniform samplerCube cubemap;', 'varying vec3 vPosition;', 'void main() {', 'gl_FragColor = textureCube(cubemap, normalize(vPosition));', '}'].join('\\n')\n\t};\n\t\n\tvar Skybox = (function () {\n\t function Skybox(world, light) {\n\t _classCallCheck(this, Skybox);\n\t\n\t this._world = world;\n\t this._light = light;\n\t\n\t this._settings = {\n\t distance: 38000,\n\t turbidity: 10,\n\t reileigh: 2,\n\t mieCoefficient: 0.005,\n\t mieDirectionalG: 0.8,\n\t luminance: 1,\n\t // 0.48 is a cracking dusk / sunset\n\t // 0.4 is a beautiful early-morning / late-afternoon\n\t // 0.2 is a nice day time\n\t inclination: 0.48, // Elevation / inclination\n\t azimuth: 0.25 };\n\t\n\t // Facing front\n\t this._initSkybox();\n\t this._updateUniforms();\n\t this._initEvents();\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t _createClass(Skybox, [{\n\t key: '_initEvents',\n\t value: function _initEvents() {\n\t // Throttled to 1 per 100ms\n\t this._throttledWorldUpdate = (0, _lodashThrottle2['default'])(this._update, 100);\n\t this._world.on('preUpdate', this._throttledWorldUpdate, this);\n\t }\n\t }, {\n\t key: '_initSkybox',\n\t value: function _initSkybox() {\n\t // Cube camera for skybox\n\t this._cubeCamera = new _three2['default'].CubeCamera(1, 2000000, 128);\n\t\n\t // Cube material\n\t var cubeTarget = this._cubeCamera.renderTarget;\n\t\n\t // Add Sky Mesh\n\t this._sky = new _Sky2['default']();\n\t this._skyScene = new _three2['default'].Scene();\n\t this._skyScene.add(this._sky.mesh);\n\t\n\t // Add Sun Helper\n\t this._sunSphere = new _three2['default'].Mesh(new _three2['default'].SphereBufferGeometry(2000, 16, 8), new _three2['default'].MeshBasicMaterial({\n\t color: 0xffffff\n\t }));\n\t\n\t // TODO: This isn't actually visible because it's not added to the layer\n\t // this._sunSphere.visible = true;\n\t\n\t var skyboxUniforms = {\n\t cubemap: { type: 't', value: cubeTarget }\n\t };\n\t\n\t var skyboxMat = new _three2['default'].ShaderMaterial({\n\t uniforms: skyboxUniforms,\n\t vertexShader: cubemap.vertexShader,\n\t fragmentShader: cubemap.fragmentShader,\n\t side: _three2['default'].BackSide\n\t });\n\t\n\t this._mesh = new _three2['default'].Mesh(new _three2['default'].BoxGeometry(190000, 190000, 190000), skyboxMat);\n\t }\n\t }, {\n\t key: '_updateUniforms',\n\t value: function _updateUniforms() {\n\t var settings = this._settings;\n\t var uniforms = this._sky.uniforms;\n\t uniforms.turbidity.value = settings.turbidity;\n\t uniforms.reileigh.value = settings.reileigh;\n\t uniforms.luminance.value = settings.luminance;\n\t uniforms.mieCoefficient.value = settings.mieCoefficient;\n\t uniforms.mieDirectionalG.value = settings.mieDirectionalG;\n\t\n\t var theta = Math.PI * (settings.inclination - 0.5);\n\t var phi = 2 * Math.PI * (settings.azimuth - 0.5);\n\t\n\t this._sunSphere.position.x = settings.distance * Math.cos(phi);\n\t this._sunSphere.position.y = settings.distance * Math.sin(phi) * Math.sin(theta);\n\t this._sunSphere.position.z = settings.distance * Math.sin(phi) * Math.cos(theta);\n\t\n\t // Move directional light to sun position\n\t this._light.position.copy(this._sunSphere.position);\n\t\n\t this._sky.uniforms.sunPosition.value.copy(this._sunSphere.position);\n\t }\n\t }, {\n\t key: '_update',\n\t value: function _update(delta) {\n\t if (!this._done) {\n\t this._done = true;\n\t } else {\n\t return;\n\t }\n\t\n\t // if (!this._angle) {\n\t // this._angle = 0;\n\t // }\n\t //\n\t // // Animate inclination\n\t // this._angle += Math.PI * delta;\n\t // this._settings.inclination = 0.5 * (Math.sin(this._angle) / 2 + 0.5);\n\t\n\t // Update light intensity depending on elevation of sun (day to night)\n\t this._light.intensity = 1 - 0.95 * (this._settings.inclination / 0.5);\n\t\n\t // // console.log(delta, this._angle, this._settings.inclination);\n\t //\n\t // TODO: Only do this when the uniforms have been changed\n\t this._updateUniforms();\n\t\n\t // TODO: Only do this when the cubemap has actually changed\n\t this._cubeCamera.updateCubeMap(this._world._engine._renderer, this._skyScene);\n\t }\n\t }, {\n\t key: 'getRenderTarget',\n\t value: function getRenderTarget() {\n\t return this._cubeCamera.renderTarget;\n\t }\n\t\n\t // Destroy the skybox and remove it from memory\n\t }, {\n\t key: 'destroy',\n\t value: function destroy() {\n\t this._world.off('preUpdate', this._throttledWorldUpdate);\n\t this._throttledWorldUpdate = null;\n\t\n\t this._world = null;\n\t this._light = null;\n\t\n\t this._cubeCamera = null;\n\t\n\t this._sky.mesh.geometry.dispose();\n\t this._sky.mesh.geometry = null;\n\t\n\t if (this._sky.mesh.material.map) {\n\t this._sky.mesh.material.map.dispose();\n\t this._sky.mesh.material.map = null;\n\t }\n\t\n\t this._sky.mesh.material.dispose();\n\t this._sky.mesh.material = null;\n\t\n\t this._sky.mesh = null;\n\t this._sky = null;\n\t\n\t this._skyScene = null;\n\t\n\t this._sunSphere.geometry.dispose();\n\t this._sunSphere.geometry = null;\n\t\n\t if (this._sunSphere.material.map) {\n\t this._sunSphere.material.map.dispose();\n\t this._sunSphere.material.map = null;\n\t }\n\t\n\t this._sunSphere.material.dispose();\n\t this._sunSphere.material = null;\n\t\n\t this._sunSphere = null;\n\t\n\t this._mesh.geometry.dispose();\n\t this._mesh.geometry = null;\n\t\n\t if (this._mesh.material.map) {\n\t this._mesh.material.map.dispose();\n\t this._mesh.material.map = null;\n\t }\n\t\n\t this._mesh.material.dispose();\n\t this._mesh.material = null;\n\t }\n\t }]);\n\t\n\t return Skybox;\n\t})();\n\t\n\texports['default'] = function (world, light) {\n\t return new Skybox(world, light);\n\t};\n\t\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\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 eqeqeq:0*/\n\t\n\t/**\n\t * @author zz85 / https://github.com/zz85\n\t *\n\t * Based on 'A Practical Analytic Model for Daylight'\n\t * aka The Preetham Model, the de facto standard analytic skydome model\n\t * http://www.cs.utah.edu/~shirley/papers/sunsky/sunsky.pdf\n\t *\n\t * First implemented by Simon Wallner\n\t * http://www.simonwallner.at/projects/atmospheric-scattering\n\t *\n\t * Improved by Martin Upitis\n\t * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR\n\t *\n\t * Three.js integration by zz85 http://twitter.com/blurspline\n\t*/\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t_three2['default'].ShaderLib['sky'] = {\n\t\n\t\tuniforms: {\n\t\n\t\t\tluminance: { type: 'f', value: 1 },\n\t\t\tturbidity: { type: 'f', value: 2 },\n\t\t\treileigh: { type: 'f', value: 1 },\n\t\t\tmieCoefficient: { type: 'f', value: 0.005 },\n\t\t\tmieDirectionalG: { type: 'f', value: 0.8 },\n\t\t\tsunPosition: { type: 'v3', value: new _three2['default'].Vector3() }\n\t\n\t\t},\n\t\n\t\tvertexShader: ['varying vec3 vWorldPosition;', 'void main() {', 'vec4 worldPosition = modelMatrix * vec4( position, 1.0 );', 'vWorldPosition = worldPosition.xyz;', 'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\\n'),\n\t\n\t\tfragmentShader: ['uniform sampler2D skySampler;', 'uniform vec3 sunPosition;', 'varying vec3 vWorldPosition;', 'vec3 cameraPos = vec3(0., 0., 0.);', '// uniform sampler2D sDiffuse;', '// const float turbidity = 10.0; //', '// const float reileigh = 2.; //', '// const float luminance = 1.0; //', '// const float mieCoefficient = 0.005;', '// const float mieDirectionalG = 0.8;', 'uniform float luminance;', 'uniform float turbidity;', 'uniform float reileigh;', 'uniform float mieCoefficient;', 'uniform float mieDirectionalG;', '// constants for atmospheric scattering', 'const float e = 2.71828182845904523536028747135266249775724709369995957;', 'const float pi = 3.141592653589793238462643383279502884197169;', 'const float n = 1.0003; // refractive index of air', 'const float N = 2.545E25; // number of molecules per unit volume for air at', '// 288.15K and 1013mb (sea level -45 celsius)', 'const float pn = 0.035;\t// depolatization factor for standard air', '// wavelength of used primaries, according to preetham', 'const vec3 lambda = vec3(680E-9, 550E-9, 450E-9);', '// mie stuff', '// K coefficient for the primaries', 'const vec3 K = vec3(0.686, 0.678, 0.666);', 'const float v = 4.0;', '// optical length at zenith for molecules', 'const float rayleighZenithLength = 8.4E3;', 'const float mieZenithLength = 1.25E3;', 'const vec3 up = vec3(0.0, 1.0, 0.0);', 'const float EE = 1000.0;', 'const float sunAngularDiameterCos = 0.999956676946448443553574619906976478926848692873900859324;', '// 66 arc seconds -> degrees, and the cosine of that', '// earth shadow hack', 'const float cutoffAngle = pi/1.95;', 'const float steepness = 1.5;', 'vec3 totalRayleigh(vec3 lambda)', '{', 'return (8.0 * pow(pi, 3.0) * pow(pow(n, 2.0) - 1.0, 2.0) * (6.0 + 3.0 * pn)) / (3.0 * N * pow(lambda, vec3(4.0)) * (6.0 - 7.0 * pn));', '}',\n\t\n\t\t// see http://blenderartists.org/forum/showthread.php?321110-Shaders-and-Skybox-madness\n\t\t'// A simplied version of the total Reayleigh scattering to works on browsers that use ANGLE', 'vec3 simplifiedRayleigh()', '{', 'return 0.0005 / vec3(94, 40, 18);',\n\t\t// return 0.00054532832366 / (3.0 * 2.545E25 * pow(vec3(680E-9, 550E-9, 450E-9), vec3(4.0)) * 6.245);\n\t\t'}', 'float rayleighPhase(float cosTheta)', '{\t ', 'return (3.0 / (16.0*pi)) * (1.0 + pow(cosTheta, 2.0));', '//\treturn (1.0 / (3.0*pi)) * (1.0 + pow(cosTheta, 2.0));', '//\treturn (3.0 / 4.0) * (1.0 + pow(cosTheta, 2.0));', '}', 'vec3 totalMie(vec3 lambda, vec3 K, float T)', '{', 'float c = (0.2 * T ) * 10E-18;', 'return 0.434 * c * pi * pow((2.0 * pi) / lambda, vec3(v - 2.0)) * K;', '}', 'float hgPhase(float cosTheta, float g)', '{', 'return (1.0 / (4.0*pi)) * ((1.0 - pow(g, 2.0)) / pow(1.0 - 2.0*g*cosTheta + pow(g, 2.0), 1.5));', '}', 'float sunIntensity(float zenithAngleCos)', '{', 'return EE * max(0.0, 1.0 - exp(-((cutoffAngle - acos(zenithAngleCos))/steepness)));', '}', '// float logLuminance(vec3 c)', '// {', '// \treturn log(c.r * 0.2126 + c.g * 0.7152 + c.b * 0.0722);', '// }', '// Filmic ToneMapping http://filmicgames.com/archives/75', 'float A = 0.15;', 'float B = 0.50;', 'float C = 0.10;', 'float D = 0.20;', 'float E = 0.02;', 'float F = 0.30;', 'float W = 1000.0;', 'vec3 Uncharted2Tonemap(vec3 x)', '{', 'return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;', '}', 'void main() ', '{', 'float sunfade = 1.0-clamp(1.0-exp((sunPosition.y/450000.0)),0.0,1.0);', '// luminance = 1.0 ;// vWorldPosition.y / 450000. + 0.5; //sunPosition.y / 450000. * 1. + 0.5;', '// gl_FragColor = vec4(sunfade, sunfade, sunfade, 1.0);', 'float reileighCoefficient = reileigh - (1.0* (1.0-sunfade));', 'vec3 sunDirection = normalize(sunPosition);', 'float sunE = sunIntensity(dot(sunDirection, up));', '// extinction (absorbtion + out scattering) ', '// rayleigh coefficients',\n\t\n\t\t// 'vec3 betaR = totalRayleigh(lambda) * reileighCoefficient;',\n\t\t'vec3 betaR = simplifiedRayleigh() * reileighCoefficient;', '// mie coefficients', 'vec3 betaM = totalMie(lambda, K, turbidity) * mieCoefficient;', '// optical length', '// cutoff angle at 90 to avoid singularity in next formula.', 'float zenithAngle = acos(max(0.0, dot(up, normalize(vWorldPosition - cameraPos))));', 'float sR = rayleighZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));', 'float sM = mieZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));', '// combined extinction factor\t', 'vec3 Fex = exp(-(betaR * sR + betaM * sM));', '// in scattering', 'float cosTheta = dot(normalize(vWorldPosition - cameraPos), sunDirection);', 'float rPhase = rayleighPhase(cosTheta*0.5+0.5);', 'vec3 betaRTheta = betaR * rPhase;', 'float mPhase = hgPhase(cosTheta, mieDirectionalG);', 'vec3 betaMTheta = betaM * mPhase;', 'vec3 Lin = pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * (1.0 - Fex),vec3(1.5));', 'Lin *= mix(vec3(1.0),pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * Fex,vec3(1.0/2.0)),clamp(pow(1.0-dot(up, sunDirection),5.0),0.0,1.0));', '//nightsky', 'vec3 direction = normalize(vWorldPosition - cameraPos);', 'float theta = acos(direction.y); // elevation --> y-axis, [-pi/2, pi/2]', 'float phi = atan(direction.z, direction.x); // azimuth --> x-axis [-pi/2, pi/2]', 'vec2 uv = vec2(phi, theta) / vec2(2.0*pi, pi) + vec2(0.5, 0.0);', '// vec3 L0 = texture2D(skySampler, uv).rgb+0.1 * Fex;', 'vec3 L0 = vec3(0.1) * Fex;', '// composition + solar disc', '//if (cosTheta > sunAngularDiameterCos)', 'float sundisk = smoothstep(sunAngularDiameterCos,sunAngularDiameterCos+0.00002,cosTheta);', '// if (normalize(vWorldPosition - cameraPos).y>0.0)', 'L0 += (sunE * 19000.0 * Fex)*sundisk;', 'vec3 whiteScale = 1.0/Uncharted2Tonemap(vec3(W));', 'vec3 texColor = (Lin+L0); ', 'texColor *= 0.04 ;', 'texColor += vec3(0.0,0.001,0.0025)*0.3;', 'float g_fMaxLuminance = 1.0;', 'float fLumScaled = 0.1 / luminance; ', 'float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (g_fMaxLuminance * g_fMaxLuminance)))) / (1.0 + fLumScaled); ', 'float ExposureBias = fLumCompressed;', 'vec3 curr = Uncharted2Tonemap((log2(2.0/pow(luminance,4.0)))*texColor);', 'vec3 color = curr*whiteScale;', 'vec3 retColor = pow(color,vec3(1.0/(1.2+(1.2*sunfade))));', 'gl_FragColor.rgb = retColor;', 'gl_FragColor.a = 1.0;', '}'].join('\\n')\n\t\n\t};\n\t\n\tvar Sky = function Sky() {\n\t\n\t\tvar skyShader = _three2['default'].ShaderLib['sky'];\n\t\tvar skyUniforms = _three2['default'].UniformsUtils.clone(skyShader.uniforms);\n\t\n\t\tvar skyMat = new _three2['default'].ShaderMaterial({\n\t\t\tfragmentShader: skyShader.fragmentShader,\n\t\t\tvertexShader: skyShader.vertexShader,\n\t\t\tuniforms: skyUniforms,\n\t\t\tside: _three2['default'].BackSide\n\t\t});\n\t\n\t\tvar skyGeo = new _three2['default'].SphereBufferGeometry(450000, 32, 15);\n\t\tvar skyMesh = new _three2['default'].Mesh(skyGeo, skyMat);\n\t\n\t\t// Expose variables\n\t\tthis.mesh = skyMesh;\n\t\tthis.uniforms = skyUniforms;\n\t};\n\t\n\texports['default'] = Sky;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 35 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t * lodash 4.0.0 (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t * Available under MIT license <https://lodash.com/license>\n\t */\n\tvar debounce = __webpack_require__(36);\n\t\n\t/** Used as the `TypeError` message for \"Functions\" methods. */\n\tvar FUNC_ERROR_TEXT = 'Expected a function';\n\t\n\t/**\n\t * Creates a throttled function that only invokes `func` at most once per\n\t * every `wait` milliseconds. The throttled function comes with a `cancel`\n\t * method to cancel delayed `func` invocations and a `flush` method to\n\t * immediately invoke them. Provide an options object to indicate whether\n\t * `func` should be invoked on the leading and/or trailing edge of the `wait`\n\t * timeout. The `func` is invoked with the last arguments provided to the\n\t * throttled function. Subsequent calls to the throttled function return the\n\t * result of the last `func` invocation.\n\t *\n\t * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n\t * on the trailing edge of the timeout only if the the throttled function is\n\t * invoked more than once during the `wait` timeout.\n\t *\n\t * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n\t * for details over the differences between `_.throttle` and `_.debounce`.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @category Function\n\t * @param {Function} func The function to throttle.\n\t * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n\t * @param {Object} [options] The options object.\n\t * @param {boolean} [options.leading=true] Specify invoking on the leading\n\t * edge of the timeout.\n\t * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n\t * edge of the timeout.\n\t * @returns {Function} Returns the new throttled function.\n\t * @example\n\t *\n\t * // avoid excessively updating the position while scrolling\n\t * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n\t *\n\t * // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes\n\t * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n\t * jQuery(element).on('click', throttled);\n\t *\n\t * // cancel a trailing throttled invocation\n\t * jQuery(window).on('popstate', throttled.cancel);\n\t */\n\tfunction throttle(func, wait, options) {\n\t var leading = true,\n\t trailing = true;\n\t\n\t if (typeof func != 'function') {\n\t throw new TypeError(FUNC_ERROR_TEXT);\n\t }\n\t if (isObject(options)) {\n\t leading = 'leading' in options ? !!options.leading : leading;\n\t trailing = 'trailing' in options ? !!options.trailing : trailing;\n\t }\n\t return debounce(func, wait, { 'leading': leading, 'maxWait': wait, 'trailing': trailing });\n\t}\n\t\n\t/**\n\t * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n\t * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\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 // Avoid a V8 JIT bug in Chrome 19-20.\n\t // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n\t var type = typeof value;\n\t return !!value && (type == 'object' || type == 'function');\n\t}\n\t\n\tmodule.exports = throttle;\n\n\n/***/ },\n/* 36 */\n/***/ function(module, exports) {\n\n\t/**\n\t * lodash 4.0.1 (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t * Available under MIT license <https://lodash.com/license>\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 NAN = 0 / 0;\n\t\n\t/** `Object#toString` result references. */\n\tvar funcTag = '[object Function]',\n\t genTag = '[object GeneratorFunction]';\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/** Used for built-in method references. */\n\tvar objectProto = Object.prototype;\n\t\n\t/**\n\t * Used to resolve the [`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 * Gets the timestamp of the number of milliseconds that have elapsed since\n\t * the Unix epoch (1 January 1970 00:00:00 UTC).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @type Function\n\t * @category Date\n\t * @returns {number} Returns the timestamp.\n\t * @example\n\t *\n\t * _.defer(function(stamp) {\n\t * console.log(_.now() - stamp);\n\t * }, _.now());\n\t * // => logs the number of milliseconds it took for the deferred function to be invoked\n\t */\n\tvar now = Date.now;\n\t\n\t/**\n\t * Creates a debounced function that delays invoking `func` until after `wait`\n\t * milliseconds have elapsed since the last time the debounced function was\n\t * invoked. The debounced function comes with a `cancel` method to cancel\n\t * delayed `func` invocations and a `flush` method to immediately invoke them.\n\t * Provide an options object to indicate whether `func` should be invoked on\n\t * the leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n\t * with the last arguments provided to the debounced function. Subsequent calls\n\t * to the debounced function return the result of the last `func` invocation.\n\t *\n\t * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n\t * on the trailing edge of the timeout only if the the debounced function is\n\t * invoked more than once during the `wait` timeout.\n\t *\n\t * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n\t * for details over the differences between `_.debounce` and `_.throttle`.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @category Function\n\t * @param {Function} func The function to debounce.\n\t * @param {number} [wait=0] The number of milliseconds to delay.\n\t * @param {Object} [options] The options object.\n\t * @param {boolean} [options.leading=false] Specify invoking on the leading\n\t * edge of the timeout.\n\t * @param {number} [options.maxWait] The maximum time `func` is allowed to be\n\t * delayed before it's invoked.\n\t * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n\t * edge of the timeout.\n\t * @returns {Function} Returns the new debounced function.\n\t * @example\n\t *\n\t * // Avoid costly calculations while the window size is in flux.\n\t * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n\t *\n\t * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n\t * jQuery(element).on('click', _.debounce(sendMail, 300, {\n\t * 'leading': true,\n\t * 'trailing': false\n\t * }));\n\t *\n\t * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n\t * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n\t * var source = new EventSource('/stream');\n\t * jQuery(source).on('message', debounced);\n\t *\n\t * // Cancel the trailing debounced invocation.\n\t * jQuery(window).on('popstate', debounced.cancel);\n\t */\n\tfunction debounce(func, wait, options) {\n\t var args,\n\t maxTimeoutId,\n\t result,\n\t stamp,\n\t thisArg,\n\t timeoutId,\n\t trailingCall,\n\t lastCalled = 0,\n\t leading = false,\n\t maxWait = false,\n\t trailing = true;\n\t\n\t if (typeof func != 'function') {\n\t throw new TypeError(FUNC_ERROR_TEXT);\n\t }\n\t wait = toNumber(wait) || 0;\n\t if (isObject(options)) {\n\t leading = !!options.leading;\n\t maxWait = 'maxWait' in options && nativeMax(toNumber(options.maxWait) || 0, wait);\n\t trailing = 'trailing' in options ? !!options.trailing : trailing;\n\t }\n\t\n\t function cancel() {\n\t if (timeoutId) {\n\t clearTimeout(timeoutId);\n\t }\n\t if (maxTimeoutId) {\n\t clearTimeout(maxTimeoutId);\n\t }\n\t lastCalled = 0;\n\t args = maxTimeoutId = thisArg = timeoutId = trailingCall = undefined;\n\t }\n\t\n\t function complete(isCalled, id) {\n\t if (id) {\n\t clearTimeout(id);\n\t }\n\t maxTimeoutId = timeoutId = trailingCall = undefined;\n\t if (isCalled) {\n\t lastCalled = now();\n\t result = func.apply(thisArg, args);\n\t if (!timeoutId && !maxTimeoutId) {\n\t args = thisArg = undefined;\n\t }\n\t }\n\t }\n\t\n\t function delayed() {\n\t var remaining = wait - (now() - stamp);\n\t if (remaining <= 0 || remaining > wait) {\n\t complete(trailingCall, maxTimeoutId);\n\t } else {\n\t timeoutId = setTimeout(delayed, remaining);\n\t }\n\t }\n\t\n\t function flush() {\n\t if ((timeoutId && trailingCall) || (maxTimeoutId && trailing)) {\n\t result = func.apply(thisArg, args);\n\t }\n\t cancel();\n\t return result;\n\t }\n\t\n\t function maxDelayed() {\n\t complete(trailing, timeoutId);\n\t }\n\t\n\t function debounced() {\n\t args = arguments;\n\t stamp = now();\n\t thisArg = this;\n\t trailingCall = trailing && (timeoutId || !leading);\n\t\n\t if (maxWait === false) {\n\t var leadingCall = leading && !timeoutId;\n\t } else {\n\t if (!maxTimeoutId && !leading) {\n\t lastCalled = stamp;\n\t }\n\t var remaining = maxWait - (stamp - lastCalled),\n\t isCalled = remaining <= 0 || remaining > maxWait;\n\t\n\t if (isCalled) {\n\t if (maxTimeoutId) {\n\t maxTimeoutId = clearTimeout(maxTimeoutId);\n\t }\n\t lastCalled = stamp;\n\t result = func.apply(thisArg, args);\n\t }\n\t else if (!maxTimeoutId) {\n\t maxTimeoutId = setTimeout(maxDelayed, remaining);\n\t }\n\t }\n\t if (isCalled && timeoutId) {\n\t timeoutId = clearTimeout(timeoutId);\n\t }\n\t else if (!timeoutId && wait !== maxWait) {\n\t timeoutId = setTimeout(delayed, wait);\n\t }\n\t if (leadingCall) {\n\t isCalled = true;\n\t result = func.apply(thisArg, args);\n\t }\n\t if (isCalled && !timeoutId && !maxTimeoutId) {\n\t args = thisArg = undefined;\n\t }\n\t return result;\n\t }\n\t debounced.cancel = cancel;\n\t debounced.flush = flush;\n\t return debounced;\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 * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n\t // 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 [language type](https://es5.github.io/#x8) of `Object`.\n\t * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\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 * Converts `value` to a number.\n\t *\n\t * @static\n\t * @memberOf _\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);\n\t * // => 3\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');\n\t * // => 3\n\t */\n\tfunction toNumber(value) {\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 = debounce;\n\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\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 _TileLayer2 = __webpack_require__(38);\n\t\n\tvar _TileLayer3 = _interopRequireDefault(_TileLayer2);\n\t\n\tvar _ImageTile = __webpack_require__(48);\n\t\n\tvar _ImageTile2 = _interopRequireDefault(_ImageTile);\n\t\n\tvar _ImageTileLayerBaseMaterial = __webpack_require__(51);\n\t\n\tvar _ImageTileLayerBaseMaterial2 = _interopRequireDefault(_ImageTileLayerBaseMaterial);\n\t\n\tvar _lodashThrottle = __webpack_require__(35);\n\t\n\tvar _lodashThrottle2 = _interopRequireDefault(_lodashThrottle);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\t// DONE: Find a way to avoid the flashing caused by the gap between old tiles\n\t// being removed and the new tiles being ready for display\n\t//\n\t// DONE: Simplest first step for MVP would be to give each tile mesh the colour\n\t// of the basemap ground so it blends in a little more, or have a huge ground\n\t// plane underneath all the tiles that shows through between tile updates.\n\t//\n\t// Could keep the old tiles around until the new ones are ready, though they'd\n\t// probably need to be layered in a way so the old tiles don't overlap new ones,\n\t// which is similar to how Leaflet approaches this (it has 2 layers)\n\t//\n\t// Could keep the tile from the previous quadtree level visible until all 4\n\t// tiles at the new / current level have finished loading and are displayed.\n\t// Perhaps by keeping a map of tiles by quadcode and a boolean for each of the\n\t// child quadcodes showing whether they are loaded and in view. If all true then\n\t// remove the parent tile, otherwise keep it on a lower layer.\n\t\n\t// TODO: Load and display a base layer separate to the LOD grid that is at a low\n\t// resolution – used as a backup / background to fill in empty areas / distance\n\t\n\t// DONE: Fix the issue where some tiles just don't load, or at least the texture\n\t// never shows up – tends to happen if you quickly zoom in / out past it while\n\t// it's still loading, leaving a blank space\n\t\n\t// TODO: Optimise the request of many image tiles – look at how Leaflet and\n\t// OpenWebGlobe approach this (eg. batching, queues, etc)\n\t\n\t// TODO: Cancel pending tile requests if they get removed from view before they\n\t// reach a ready state (eg. cancel image requests, etc). Need to ensure that the\n\t// images are re-requested when the tile is next in scene (even if from cache)\n\t\n\t// TODO: Consider not performing an LOD calculation on every frame, instead only\n\t// on move end so panning, orbiting and zooming stays smooth. Otherwise it's\n\t// possible for performance to tank if you pan, orbit or zoom rapidly while all\n\t// the LOD calculations are being made and new tiles requested.\n\t//\n\t// Pending tiles should continue to be requested and output to the scene on each\n\t// frame, but no new LOD calculations should be made.\n\t\n\tvar ImageTileLayer = (function (_TileLayer) {\n\t _inherits(ImageTileLayer, _TileLayer);\n\t\n\t function ImageTileLayer(path, options) {\n\t _classCallCheck(this, ImageTileLayer);\n\t\n\t var defaults = {\n\t distance: 40000\n\t };\n\t\n\t options = (0, _lodashAssign2['default'])(defaults, options);\n\t\n\t _get(Object.getPrototypeOf(ImageTileLayer.prototype), 'constructor', this).call(this, options);\n\t\n\t this._path = path;\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t _createClass(ImageTileLayer, [{\n\t key: '_onAdd',\n\t value: function _onAdd(world) {\n\t var _this = this;\n\t\n\t _get(Object.getPrototypeOf(ImageTileLayer.prototype), '_onAdd', this).call(this, world);\n\t\n\t // Add base layer\n\t var geom = new _three2['default'].PlaneBufferGeometry(200000, 200000, 1);\n\t\n\t var baseMaterial;\n\t if (this._world._environment._skybox) {\n\t baseMaterial = (0, _ImageTileLayerBaseMaterial2['default'])('#f5f5f3', this._world._environment._skybox.getRenderTarget());\n\t } else {\n\t baseMaterial = (0, _ImageTileLayerBaseMaterial2['default'])('#f5f5f3');\n\t }\n\t\n\t var mesh = new _three2['default'].Mesh(geom, baseMaterial);\n\t mesh.rotation.x = -90 * Math.PI / 180;\n\t\n\t // TODO: It might be overkill to receive a shadow on the base layer as it's\n\t // rarely seen (good to have if performance difference is negligible)\n\t mesh.receiveShadow = true;\n\t\n\t this._baseLayer = mesh;\n\t this.add(mesh);\n\t\n\t // Trigger initial quadtree calculation on the next frame\n\t //\n\t // TODO: This is a hack to ensure the camera is all set up - a better\n\t // solution should be found\n\t setTimeout(function () {\n\t _this._calculateLOD();\n\t _this._initEvents();\n\t }, 0);\n\t }\n\t }, {\n\t key: '_initEvents',\n\t value: function _initEvents() {\n\t // Run LOD calculations based on render calls\n\t //\n\t // Throttled to 1 LOD calculation per 100ms\n\t this._throttledWorldUpdate = (0, _lodashThrottle2['default'])(this._onWorldUpdate, 100);\n\t\n\t this._world.on('preUpdate', this._throttledWorldUpdate, this);\n\t this._world.on('move', this._onWorldMove, this);\n\t }\n\t }, {\n\t key: '_onWorldUpdate',\n\t value: function _onWorldUpdate() {\n\t this._calculateLOD();\n\t }\n\t }, {\n\t key: '_onWorldMove',\n\t value: function _onWorldMove(latlon, point) {\n\t this._moveBaseLayer(point);\n\t }\n\t }, {\n\t key: '_moveBaseLayer',\n\t value: function _moveBaseLayer(point) {\n\t this._baseLayer.position.x = point.x;\n\t this._baseLayer.position.z = point.y;\n\t }\n\t }, {\n\t key: '_createTile',\n\t value: function _createTile(quadcode, layer) {\n\t return (0, _ImageTile2['default'])(quadcode, this._path, layer);\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 this._world.off('preUpdate', this._throttledWorldUpdate);\n\t this._world.off('move', this._onWorldMove);\n\t\n\t this._throttledWorldUpdate = null;\n\t\n\t // Dispose of mesh and materials\n\t this._baseLayer.geometry.dispose();\n\t this._baseLayer.geometry = null;\n\t\n\t if (this._baseLayer.material.map) {\n\t this._baseLayer.material.map.dispose();\n\t this._baseLayer.material.map = null;\n\t }\n\t\n\t this._baseLayer.material.dispose();\n\t this._baseLayer.material = null;\n\t\n\t this._baseLayer = null;\n\t\n\t // Run common destruction logic from parent\n\t _get(Object.getPrototypeOf(ImageTileLayer.prototype), 'destroy', this).call(this);\n\t }\n\t }]);\n\t\n\t return ImageTileLayer;\n\t})(_TileLayer3['default']);\n\t\n\texports['default'] = function (path, options) {\n\t return new ImageTileLayer(path, options);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 38 */\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 _Layer2 = __webpack_require__(32);\n\t\n\tvar _Layer3 = _interopRequireDefault(_Layer2);\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _TileCache = __webpack_require__(39);\n\t\n\tvar _TileCache2 = _interopRequireDefault(_TileCache);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t// TODO: Consider keeping a single TileLayer / LOD instance running by default\n\t// that keeps a standard LOD grid for other layers to utilise, rather than\n\t// having to create their own, unique LOD grid and duplicate calculations when\n\t// they're going to use the same grid setup anyway\n\t//\n\t// It still makes sense to be able to have a custom LOD grid for some layers as\n\t// they may want to customise things, maybe not even using a quadtree at all!\n\t//\n\t// Perhaps it makes sense to split out the quadtree stuff into a singleton and\n\t// pass in the necessary parameters each time for the calculation step.\n\t//\n\t// Either way, it seems silly to force layers to have to create a new LOD grid\n\t// each time and create extra, duplicated processing every frame.\n\t\n\t// TODO: Allow passing in of options to define min/max LOD and a distance to use\n\t// for culling tiles beyond that distance.\n\t\n\t// DONE: Prevent tiles from being loaded if they are further than a certain\n\t// distance from the camera and are unlikely to be seen anyway\n\t\n\t// TODO: Avoid performing LOD calculation when it isn't required. For example,\n\t// when nothing has changed since the last frame and there are no tiles to be\n\t// loaded or in need of rendering\n\t\n\t// TODO: Only remove tiles from the layer that aren't to be rendered in the\n\t// current frame – it seems excessive to remove all tiles and re-add them on\n\t// every single frame, even if it's just array manipulation\n\t\n\t// TODO: Fix LOD calculation so min and max LOD can be changed without causing\n\t// problems (eg. making min above 5 causes all sorts of issues)\n\t\n\t// TODO: Reuse THREE objects where possible instead of creating new instances\n\t// on every LOD calculation\n\t\n\t// TODO: Consider not using THREE or LatLon / Point objects in LOD calculations\n\t// to avoid creating unnecessary memory for garbage collection\n\t\n\t// TODO: Prioritise loading of tiles at highest level in the quadtree (those\n\t// closest to the camera) so visual inconsistancies during loading are minimised\n\t\n\tvar TileLayer = (function (_Layer) {\n\t _inherits(TileLayer, _Layer);\n\t\n\t function TileLayer(options) {\n\t var _this = this;\n\t\n\t _classCallCheck(this, TileLayer);\n\t\n\t _get(Object.getPrototypeOf(TileLayer.prototype), 'constructor', this).call(this, options);\n\t\n\t var defaults = {\n\t maxCache: 1000,\n\t maxLOD: 18\n\t };\n\t\n\t this._options = (0, _lodashAssign2['default'])(defaults, options);\n\t\n\t this._tileCache = (0, _TileCache2['default'])(this._options.maxCache, function (tile) {\n\t _this._destroyTile(tile);\n\t });\n\t\n\t // TODO: Work out why changing the minLOD causes loads of issues\n\t this._minLOD = 3;\n\t this._maxLOD = this._options.maxLOD;\n\t\n\t this._frustum = new _three2['default'].Frustum();\n\t this._tiles = new _three2['default'].Object3D();\n\t }\n\t\n\t _createClass(TileLayer, [{\n\t key: '_onAdd',\n\t value: function _onAdd(world) {\n\t this.add(this._tiles);\n\t }\n\t }, {\n\t key: '_updateFrustum',\n\t value: function _updateFrustum() {\n\t var camera = this._world.getCamera();\n\t var projScreenMatrix = new _three2['default'].Matrix4();\n\t projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);\n\t\n\t this._frustum.setFromMatrix(camera.projectionMatrix);\n\t this._frustum.setFromMatrix(new _three2['default'].Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse));\n\t }\n\t }, {\n\t key: '_tileInFrustum',\n\t value: function _tileInFrustum(tile) {\n\t var bounds = tile.getBounds();\n\t return this._frustum.intersectsBox(new _three2['default'].Box3(new _three2['default'].Vector3(bounds[0], 0, bounds[3]), new _three2['default'].Vector3(bounds[2], 0, bounds[1])));\n\t }\n\t }, {\n\t key: '_calculateLOD',\n\t value: function _calculateLOD() {\n\t var _this2 = this;\n\t\n\t if (this._stop || !this._world) {\n\t return;\n\t }\n\t\n\t // var start = performance.now();\n\t\n\t var camera = this._world.getCamera();\n\t\n\t // 1. Update and retrieve camera frustum\n\t this._updateFrustum(this._frustum, camera);\n\t\n\t // 2. Add the four root items of the quadtree to a check list\n\t var checkList = this._checklist;\n\t checkList = [];\n\t checkList.push(this._requestTile('0', this));\n\t checkList.push(this._requestTile('1', this));\n\t checkList.push(this._requestTile('2', this));\n\t checkList.push(this._requestTile('3', this));\n\t\n\t // 3. Call Divide, passing in the check list\n\t this._divide(checkList);\n\t\n\t // 4. Remove all tiles from layer\n\t this._removeTiles();\n\t\n\t // 5. Render the tiles remaining in the check list\n\t checkList.forEach(function (tile, index) {\n\t // Skip tile if it's not in the current view frustum\n\t if (!_this2._tileInFrustum(tile)) {\n\t return;\n\t }\n\t\n\t if (_this2._options.distance && _this2._options.distance > 0) {\n\t // TODO: Can probably speed this up\n\t var center = tile.getCenter();\n\t var dist = new _three2['default'].Vector3(center[0], 0, center[1]).sub(camera.position).length();\n\t\n\t // Manual distance limit to cut down on tiles so far away\n\t if (dist > _this2._options.distance) {\n\t return;\n\t }\n\t }\n\t\n\t // Does the tile have a mesh?\n\t //\n\t // If yes, continue\n\t // If no, generate tile mesh, request texture and skip\n\t if (!tile.getMesh()) {\n\t tile.requestTileAsync();\n\t return;\n\t }\n\t\n\t // Are the mesh and texture ready?\n\t //\n\t // If yes, continue\n\t // If no, skip\n\t if (!tile.isReady()) {\n\t return;\n\t }\n\t\n\t // Add tile to layer (and to scene)\n\t _this2._tiles.add(tile.getMesh());\n\t });\n\t\n\t // console.log(performance.now() - start);\n\t }\n\t }, {\n\t key: '_divide',\n\t value: function _divide(checkList) {\n\t var count = 0;\n\t var currentItem;\n\t var quadcode;\n\t\n\t // 1. Loop until count equals check list length\n\t while (count != checkList.length) {\n\t currentItem = checkList[count];\n\t quadcode = currentItem.getQuadcode();\n\t\n\t // 2. Increase count and continue loop if quadcode equals max LOD / zoom\n\t if (currentItem.length === this._maxLOD) {\n\t count++;\n\t continue;\n\t }\n\t\n\t // 3. Else, calculate screen-space error metric for quadcode\n\t if (this._screenSpaceError(currentItem)) {\n\t // 4. If error is sufficient...\n\t\n\t // 4a. Remove parent item from the check list\n\t checkList.splice(count, 1);\n\t\n\t // 4b. Add 4 child items to the check list\n\t checkList.push(this._requestTile(quadcode + '0', this));\n\t checkList.push(this._requestTile(quadcode + '1', this));\n\t checkList.push(this._requestTile(quadcode + '2', this));\n\t checkList.push(this._requestTile(quadcode + '3', this));\n\t\n\t // 4d. Continue the loop without increasing count\n\t continue;\n\t } else {\n\t // 5. Else, increase count and continue loop\n\t count++;\n\t }\n\t }\n\t }\n\t }, {\n\t key: '_screenSpaceError',\n\t value: function _screenSpaceError(tile) {\n\t var minDepth = this._minLOD;\n\t var maxDepth = this._maxLOD;\n\t\n\t var quadcode = tile.getQuadcode();\n\t\n\t var camera = this._world.getCamera();\n\t\n\t // Tweak this value to refine specific point that each quad is subdivided\n\t //\n\t // It's used to multiple the dimensions of the tile sides before\n\t // comparing against the tile distance from camera\n\t var quality = 3.0;\n\t\n\t // 1. Return false if quadcode length equals maxDepth (stop dividing)\n\t if (quadcode.length === maxDepth) {\n\t return false;\n\t }\n\t\n\t // 2. Return true if quadcode length is less than minDepth\n\t if (quadcode.length < minDepth) {\n\t return true;\n\t }\n\t\n\t // 3. Return false if quadcode bounds are not in view frustum\n\t if (!this._tileInFrustum(tile)) {\n\t return false;\n\t }\n\t\n\t var center = tile.getCenter();\n\t\n\t // 4. Calculate screen-space error metric\n\t // TODO: Use closest distance to one of the 4 tile corners\n\t var dist = new _three2['default'].Vector3(center[0], 0, center[1]).sub(camera.position).length();\n\t\n\t var error = quality * tile.getSide() / dist;\n\t\n\t // 5. Return true if error is greater than 1.0, else return false\n\t return error > 1.0;\n\t }\n\t }, {\n\t key: '_removeTiles',\n\t value: function _removeTiles() {\n\t for (var i = this._tiles.children.length - 1; i >= 0; i--) {\n\t this._tiles.remove(this._tiles.children[i]);\n\t }\n\t }\n\t\n\t // Return a new tile instance\n\t }, {\n\t key: '_createTile',\n\t value: function _createTile(quadcode, layer) {}\n\t\n\t // Get a cached tile or request a new one if not in cache\n\t }, {\n\t key: '_requestTile',\n\t value: function _requestTile(quadcode, layer) {\n\t var tile = this._tileCache.getTile(quadcode);\n\t\n\t if (!tile) {\n\t // Set up a brand new tile\n\t tile = this._createTile(quadcode, layer);\n\t\n\t // Add tile to cache, though it won't be ready yet as the data is being\n\t // requested from various places asynchronously\n\t this._tileCache.setTile(quadcode, tile);\n\t }\n\t\n\t return tile;\n\t }\n\t }, {\n\t key: '_destroyTile',\n\t value: function _destroyTile(tile) {\n\t // Remove tile from scene\n\t this._tiles.remove(tile.getMesh());\n\t\n\t // Delete any references to the tile within this component\n\t\n\t // Call destory on tile instance\n\t tile.destroy();\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 var i;\n\t\n\t // Remove all tiles\n\t for (i = this._tiles.children.length - 1; i >= 0; i--) {\n\t this._tiles.remove(this._tiles.children[i]);\n\t }\n\t\n\t this._tileCache.destroy();\n\t this._tileCache = null;\n\t\n\t this._tiles = null;\n\t this._frustum = null;\n\t\n\t _get(Object.getPrototypeOf(TileLayer.prototype), 'destroy', this).call(this);\n\t }\n\t }]);\n\t\n\t return TileLayer;\n\t})(_Layer3['default']);\n\t\n\texports['default'] = TileLayer;\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\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 _lruCache = __webpack_require__(40);\n\t\n\tvar _lruCache2 = _interopRequireDefault(_lruCache);\n\t\n\t// This process is based on a similar approach taken by OpenWebGlobe\n\t// See: https://github.com/OpenWebGlobe/WebViewer/blob/master/source/core/globecache.js\n\t\n\tvar TileCache = (function () {\n\t function TileCache(cacheLimit, onDestroyTile) {\n\t _classCallCheck(this, TileCache);\n\t\n\t this._cache = (0, _lruCache2['default'])({\n\t max: cacheLimit,\n\t dispose: function dispose(key, tile) {\n\t onDestroyTile(tile);\n\t }\n\t });\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t // Returns true if all specified tile providers are ready to be used\n\t // Otherwise, returns false\n\t\n\t _createClass(TileCache, [{\n\t key: 'isReady',\n\t value: function isReady() {\n\t return false;\n\t }\n\t\n\t // Get a cached tile without requesting a new one\n\t }, {\n\t key: 'getTile',\n\t value: function getTile(quadcode) {\n\t return this._cache.get(quadcode);\n\t }\n\t\n\t // Add tile to cache\n\t }, {\n\t key: 'setTile',\n\t value: function setTile(quadcode, tile) {\n\t this._cache.set(quadcode, tile);\n\t }\n\t\n\t // Destroy the cache and remove it from memory\n\t //\n\t // TODO: Call destroy method on items in cache\n\t }, {\n\t key: 'destroy',\n\t value: function destroy() {\n\t this._cache.reset();\n\t this._cache = null;\n\t }\n\t }]);\n\t\n\t return TileCache;\n\t})();\n\t\n\texports['default'] = function (cacheLimit, onDestroyTile) {\n\t return new TileCache(cacheLimit, onDestroyTile);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 40 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = LRUCache\n\t\n\t// This will be a proper iterable 'Map' in engines that support it,\n\t// or a fakey-fake PseudoMap in older versions.\n\tvar Map = __webpack_require__(41)\n\tvar util = __webpack_require__(44)\n\t\n\t// A linked list to keep track of recently-used-ness\n\tvar Yallist = __webpack_require__(47)\n\t\n\t// use symbols if possible, otherwise just _props\n\tvar symbols = {}\n\tvar hasSymbol = typeof Symbol === 'function'\n\tvar makeSymbol\n\tif (hasSymbol) {\n\t makeSymbol = function (key) {\n\t return Symbol.for(key)\n\t }\n\t} else {\n\t makeSymbol = function (key) {\n\t return '_' + key\n\t }\n\t}\n\t\n\tfunction priv (obj, key, val) {\n\t var sym\n\t if (symbols[key]) {\n\t sym = symbols[key]\n\t } else {\n\t sym = makeSymbol(key)\n\t symbols[key] = sym\n\t }\n\t if (arguments.length === 2) {\n\t return obj[sym]\n\t } else {\n\t obj[sym] = val\n\t return val\n\t }\n\t}\n\t\n\tfunction naiveLength () { return 1 }\n\t\n\t// lruList is a yallist where the head is the youngest\n\t// item, and the tail is the oldest. the list contains the Hit\n\t// objects as the entries.\n\t// Each Hit object has a reference to its Yallist.Node. This\n\t// never changes.\n\t//\n\t// cache is a Map (or PseudoMap) that matches the keys to\n\t// the Yallist.Node object.\n\tfunction LRUCache (options) {\n\t if (!(this instanceof LRUCache)) {\n\t return new LRUCache(options)\n\t }\n\t\n\t if (typeof options === 'number') {\n\t options = { max: options }\n\t }\n\t\n\t if (!options) {\n\t options = {}\n\t }\n\t\n\t var max = priv(this, 'max', options.max)\n\t // Kind of weird to have a default max of Infinity, but oh well.\n\t if (!max ||\n\t !(typeof max === 'number') ||\n\t max <= 0) {\n\t priv(this, 'max', Infinity)\n\t }\n\t\n\t var lc = options.length || naiveLength\n\t if (typeof lc !== 'function') {\n\t lc = naiveLength\n\t }\n\t priv(this, 'lengthCalculator', lc)\n\t\n\t priv(this, 'allowStale', options.stale || false)\n\t priv(this, 'maxAge', options.maxAge || 0)\n\t priv(this, 'dispose', options.dispose)\n\t this.reset()\n\t}\n\t\n\t// resize the cache when the max changes.\n\tObject.defineProperty(LRUCache.prototype, 'max', {\n\t set: function (mL) {\n\t if (!mL || !(typeof mL === 'number') || mL <= 0) {\n\t mL = Infinity\n\t }\n\t priv(this, 'max', mL)\n\t trim(this)\n\t },\n\t get: function () {\n\t return priv(this, 'max')\n\t },\n\t enumerable: true\n\t})\n\t\n\tObject.defineProperty(LRUCache.prototype, 'allowStale', {\n\t set: function (allowStale) {\n\t priv(this, 'allowStale', !!allowStale)\n\t },\n\t get: function () {\n\t return priv(this, 'allowStale')\n\t },\n\t enumerable: true\n\t})\n\t\n\tObject.defineProperty(LRUCache.prototype, 'maxAge', {\n\t set: function (mA) {\n\t if (!mA || !(typeof mA === 'number') || mA < 0) {\n\t mA = 0\n\t }\n\t priv(this, 'maxAge', mA)\n\t trim(this)\n\t },\n\t get: function () {\n\t return priv(this, 'maxAge')\n\t },\n\t enumerable: true\n\t})\n\t\n\t// resize the cache when the lengthCalculator changes.\n\tObject.defineProperty(LRUCache.prototype, 'lengthCalculator', {\n\t set: function (lC) {\n\t if (typeof lC !== 'function') {\n\t lC = naiveLength\n\t }\n\t if (lC !== priv(this, 'lengthCalculator')) {\n\t priv(this, 'lengthCalculator', lC)\n\t priv(this, 'length', 0)\n\t priv(this, 'lruList').forEach(function (hit) {\n\t hit.length = priv(this, 'lengthCalculator').call(this, hit.value, hit.key)\n\t priv(this, 'length', priv(this, 'length') + hit.length)\n\t }, this)\n\t }\n\t trim(this)\n\t },\n\t get: function () { return priv(this, 'lengthCalculator') },\n\t enumerable: true\n\t})\n\t\n\tObject.defineProperty(LRUCache.prototype, 'length', {\n\t get: function () { return priv(this, 'length') },\n\t enumerable: true\n\t})\n\t\n\tObject.defineProperty(LRUCache.prototype, 'itemCount', {\n\t get: function () { return priv(this, 'lruList').length },\n\t enumerable: true\n\t})\n\t\n\tLRUCache.prototype.rforEach = function (fn, thisp) {\n\t thisp = thisp || this\n\t for (var walker = priv(this, 'lruList').tail; walker !== null;) {\n\t var prev = walker.prev\n\t forEachStep(this, fn, walker, thisp)\n\t walker = prev\n\t }\n\t}\n\t\n\tfunction forEachStep (self, fn, node, thisp) {\n\t var hit = node.value\n\t if (isStale(self, hit)) {\n\t del(self, node)\n\t if (!priv(self, 'allowStale')) {\n\t hit = undefined\n\t }\n\t }\n\t if (hit) {\n\t fn.call(thisp, hit.value, hit.key, self)\n\t }\n\t}\n\t\n\tLRUCache.prototype.forEach = function (fn, thisp) {\n\t thisp = thisp || this\n\t for (var walker = priv(this, 'lruList').head; walker !== null;) {\n\t var next = walker.next\n\t forEachStep(this, fn, walker, thisp)\n\t walker = next\n\t }\n\t}\n\t\n\tLRUCache.prototype.keys = function () {\n\t return priv(this, 'lruList').toArray().map(function (k) {\n\t return k.key\n\t }, this)\n\t}\n\t\n\tLRUCache.prototype.values = function () {\n\t return priv(this, 'lruList').toArray().map(function (k) {\n\t return k.value\n\t }, this)\n\t}\n\t\n\tLRUCache.prototype.reset = function () {\n\t if (priv(this, 'dispose') &&\n\t priv(this, 'lruList') &&\n\t priv(this, 'lruList').length) {\n\t priv(this, 'lruList').forEach(function (hit) {\n\t priv(this, 'dispose').call(this, hit.key, hit.value)\n\t }, this)\n\t }\n\t\n\t priv(this, 'cache', new Map()) // hash of items by key\n\t priv(this, 'lruList', new Yallist()) // list of items in order of use recency\n\t priv(this, 'length', 0) // length of items in the list\n\t}\n\t\n\tLRUCache.prototype.dump = function () {\n\t return priv(this, 'lruList').map(function (hit) {\n\t if (!isStale(this, hit)) {\n\t return {\n\t k: hit.key,\n\t v: hit.value,\n\t e: hit.now + (hit.maxAge || 0)\n\t }\n\t }\n\t }, this).toArray().filter(function (h) {\n\t return h\n\t })\n\t}\n\t\n\tLRUCache.prototype.dumpLru = function () {\n\t return priv(this, 'lruList')\n\t}\n\t\n\tLRUCache.prototype.inspect = function (n, opts) {\n\t var str = 'LRUCache {'\n\t var extras = false\n\t\n\t var as = priv(this, 'allowStale')\n\t if (as) {\n\t str += '\\n allowStale: true'\n\t extras = true\n\t }\n\t\n\t var max = priv(this, 'max')\n\t if (max && max !== Infinity) {\n\t if (extras) {\n\t str += ','\n\t }\n\t str += '\\n max: ' + util.inspect(max, opts)\n\t extras = true\n\t }\n\t\n\t var maxAge = priv(this, 'maxAge')\n\t if (maxAge) {\n\t if (extras) {\n\t str += ','\n\t }\n\t str += '\\n maxAge: ' + util.inspect(maxAge, opts)\n\t extras = true\n\t }\n\t\n\t var lc = priv(this, 'lengthCalculator')\n\t if (lc && lc !== naiveLength) {\n\t if (extras) {\n\t str += ','\n\t }\n\t str += '\\n length: ' + util.inspect(priv(this, 'length'), opts)\n\t extras = true\n\t }\n\t\n\t var didFirst = false\n\t priv(this, 'lruList').forEach(function (item) {\n\t if (didFirst) {\n\t str += ',\\n '\n\t } else {\n\t if (extras) {\n\t str += ',\\n'\n\t }\n\t didFirst = true\n\t str += '\\n '\n\t }\n\t var key = util.inspect(item.key).split('\\n').join('\\n ')\n\t var val = { value: item.value }\n\t if (item.maxAge !== maxAge) {\n\t val.maxAge = item.maxAge\n\t }\n\t if (lc !== naiveLength) {\n\t val.length = item.length\n\t }\n\t if (isStale(this, item)) {\n\t val.stale = true\n\t }\n\t\n\t val = util.inspect(val, opts).split('\\n').join('\\n ')\n\t str += key + ' => ' + val\n\t })\n\t\n\t if (didFirst || extras) {\n\t str += '\\n'\n\t }\n\t str += '}'\n\t\n\t return str\n\t}\n\t\n\tLRUCache.prototype.set = function (key, value, maxAge) {\n\t maxAge = maxAge || priv(this, 'maxAge')\n\t\n\t var now = maxAge ? Date.now() : 0\n\t var len = priv(this, 'lengthCalculator').call(this, value, key)\n\t\n\t if (priv(this, 'cache').has(key)) {\n\t if (len > priv(this, 'max')) {\n\t del(this, priv(this, 'cache').get(key))\n\t return false\n\t }\n\t\n\t var node = priv(this, 'cache').get(key)\n\t var item = node.value\n\t\n\t // dispose of the old one before overwriting\n\t if (priv(this, 'dispose')) {\n\t priv(this, 'dispose').call(this, key, item.value)\n\t }\n\t\n\t item.now = now\n\t item.maxAge = maxAge\n\t item.value = value\n\t priv(this, 'length', priv(this, 'length') + (len - item.length))\n\t item.length = len\n\t this.get(key)\n\t trim(this)\n\t return true\n\t }\n\t\n\t var hit = new Entry(key, value, len, now, maxAge)\n\t\n\t // oversized objects fall out of cache automatically.\n\t if (hit.length > priv(this, 'max')) {\n\t if (priv(this, 'dispose')) {\n\t priv(this, 'dispose').call(this, key, value)\n\t }\n\t return false\n\t }\n\t\n\t priv(this, 'length', priv(this, 'length') + hit.length)\n\t priv(this, 'lruList').unshift(hit)\n\t priv(this, 'cache').set(key, priv(this, 'lruList').head)\n\t trim(this)\n\t return true\n\t}\n\t\n\tLRUCache.prototype.has = function (key) {\n\t if (!priv(this, 'cache').has(key)) return false\n\t var hit = priv(this, 'cache').get(key).value\n\t if (isStale(this, hit)) {\n\t return false\n\t }\n\t return true\n\t}\n\t\n\tLRUCache.prototype.get = function (key) {\n\t return get(this, key, true)\n\t}\n\t\n\tLRUCache.prototype.peek = function (key) {\n\t return get(this, key, false)\n\t}\n\t\n\tLRUCache.prototype.pop = function () {\n\t var node = priv(this, 'lruList').tail\n\t if (!node) return null\n\t del(this, node)\n\t return node.value\n\t}\n\t\n\tLRUCache.prototype.del = function (key) {\n\t del(this, priv(this, 'cache').get(key))\n\t}\n\t\n\tLRUCache.prototype.load = function (arr) {\n\t // reset the cache\n\t this.reset()\n\t\n\t var now = Date.now()\n\t // A previous serialized cache has the most recent items first\n\t for (var l = arr.length - 1; l >= 0; l--) {\n\t var hit = arr[l]\n\t var expiresAt = hit.e || 0\n\t if (expiresAt === 0) {\n\t // the item was created without expiration in a non aged cache\n\t this.set(hit.k, hit.v)\n\t } else {\n\t var maxAge = expiresAt - now\n\t // dont add already expired items\n\t if (maxAge > 0) {\n\t this.set(hit.k, hit.v, maxAge)\n\t }\n\t }\n\t }\n\t}\n\t\n\tLRUCache.prototype.prune = function () {\n\t var self = this\n\t priv(this, 'cache').forEach(function (value, key) {\n\t get(self, key, false)\n\t })\n\t}\n\t\n\tfunction get (self, key, doUse) {\n\t var node = priv(self, 'cache').get(key)\n\t if (node) {\n\t var hit = node.value\n\t if (isStale(self, hit)) {\n\t del(self, node)\n\t if (!priv(self, 'allowStale')) hit = undefined\n\t } else {\n\t if (doUse) {\n\t priv(self, 'lruList').unshiftNode(node)\n\t }\n\t }\n\t if (hit) hit = hit.value\n\t }\n\t return hit\n\t}\n\t\n\tfunction isStale (self, hit) {\n\t if (!hit || (!hit.maxAge && !priv(self, 'maxAge'))) {\n\t return false\n\t }\n\t var stale = false\n\t var diff = Date.now() - hit.now\n\t if (hit.maxAge) {\n\t stale = diff > hit.maxAge\n\t } else {\n\t stale = priv(self, 'maxAge') && (diff > priv(self, 'maxAge'))\n\t }\n\t return stale\n\t}\n\t\n\tfunction trim (self) {\n\t if (priv(self, 'length') > priv(self, 'max')) {\n\t for (var walker = priv(self, 'lruList').tail;\n\t priv(self, 'length') > priv(self, 'max') && walker !== null;) {\n\t // We know that we're about to delete this one, and also\n\t // what the next least recently used key will be, so just\n\t // go ahead and set it now.\n\t var prev = walker.prev\n\t del(self, walker)\n\t walker = prev\n\t }\n\t }\n\t}\n\t\n\tfunction del (self, node) {\n\t if (node) {\n\t var hit = node.value\n\t if (priv(self, 'dispose')) {\n\t priv(self, 'dispose').call(this, hit.key, hit.value)\n\t }\n\t priv(self, 'length', priv(self, 'length') - hit.length)\n\t priv(self, 'cache').delete(hit.key)\n\t priv(self, 'lruList').removeNode(node)\n\t }\n\t}\n\t\n\t// classy, since V8 prefers predictable objects.\n\tfunction Entry (key, value, length, now, maxAge) {\n\t this.key = key\n\t this.value = value\n\t this.length = length\n\t this.now = now\n\t this.maxAge = maxAge || 0\n\t}\n\n\n/***/ },\n/* 41 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(process) {if (process.env.npm_package_name === 'pseudomap' &&\n\t process.env.npm_lifecycle_script === 'test')\n\t process.env.TEST_PSEUDOMAP = 'true'\n\t\n\tif (typeof Map === 'function' && !process.env.TEST_PSEUDOMAP) {\n\t module.exports = Map\n\t} else {\n\t module.exports = __webpack_require__(43)\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(42)))\n\n/***/ },\n/* 42 */\n/***/ function(module, exports) {\n\n\t// shim for using process in browser\n\t\n\tvar process = module.exports = {};\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\t\n\tfunction cleanUpNextTick() {\n\t draining = false;\n\t if (currentQueue.length) {\n\t queue = currentQueue.concat(queue);\n\t } else {\n\t queueIndex = -1;\n\t }\n\t if (queue.length) {\n\t drainQueue();\n\t }\n\t}\n\t\n\tfunction drainQueue() {\n\t if (draining) {\n\t return;\n\t }\n\t var timeout = setTimeout(cleanUpNextTick);\n\t draining = true;\n\t\n\t var len = queue.length;\n\t while(len) {\n\t currentQueue = queue;\n\t queue = [];\n\t while (++queueIndex < len) {\n\t if (currentQueue) {\n\t currentQueue[queueIndex].run();\n\t }\n\t }\n\t queueIndex = -1;\n\t len = queue.length;\n\t }\n\t currentQueue = null;\n\t draining = false;\n\t clearTimeout(timeout);\n\t}\n\t\n\tprocess.nextTick = function (fun) {\n\t var args = new Array(arguments.length - 1);\n\t if (arguments.length > 1) {\n\t for (var i = 1; i < arguments.length; i++) {\n\t args[i - 1] = arguments[i];\n\t }\n\t }\n\t queue.push(new Item(fun, args));\n\t if (queue.length === 1 && !draining) {\n\t setTimeout(drainQueue, 0);\n\t }\n\t};\n\t\n\t// v8 likes predictible objects\n\tfunction Item(fun, array) {\n\t this.fun = fun;\n\t this.array = array;\n\t}\n\tItem.prototype.run = function () {\n\t this.fun.apply(null, this.array);\n\t};\n\tprocess.title = 'browser';\n\tprocess.browser = true;\n\tprocess.env = {};\n\tprocess.argv = [];\n\tprocess.version = ''; // empty string to avoid regexp issues\n\tprocess.versions = {};\n\t\n\tfunction noop() {}\n\t\n\tprocess.on = noop;\n\tprocess.addListener = noop;\n\tprocess.once = noop;\n\tprocess.off = noop;\n\tprocess.removeListener = noop;\n\tprocess.removeAllListeners = noop;\n\tprocess.emit = noop;\n\t\n\tprocess.binding = function (name) {\n\t throw new Error('process.binding is not supported');\n\t};\n\t\n\tprocess.cwd = function () { return '/' };\n\tprocess.chdir = function (dir) {\n\t throw new Error('process.chdir is not supported');\n\t};\n\tprocess.umask = function() { return 0; };\n\n\n/***/ },\n/* 43 */\n/***/ function(module, exports) {\n\n\tvar hasOwnProperty = Object.prototype.hasOwnProperty\n\t\n\tmodule.exports = PseudoMap\n\t\n\tfunction PseudoMap (set) {\n\t if (!(this instanceof PseudoMap)) // whyyyyyyy\n\t throw new TypeError(\"Constructor PseudoMap requires 'new'\")\n\t\n\t this.clear()\n\t\n\t if (set) {\n\t if ((set instanceof PseudoMap) ||\n\t (typeof Map === 'function' && set instanceof Map))\n\t set.forEach(function (value, key) {\n\t this.set(key, value)\n\t }, this)\n\t else if (Array.isArray(set))\n\t set.forEach(function (kv) {\n\t this.set(kv[0], kv[1])\n\t }, this)\n\t else\n\t throw new TypeError('invalid argument')\n\t }\n\t}\n\t\n\tPseudoMap.prototype.forEach = function (fn, thisp) {\n\t thisp = thisp || this\n\t Object.keys(this._data).forEach(function (k) {\n\t if (k !== 'size')\n\t fn.call(thisp, this._data[k].value, this._data[k].key)\n\t }, this)\n\t}\n\t\n\tPseudoMap.prototype.has = function (k) {\n\t return !!find(this._data, k)\n\t}\n\t\n\tPseudoMap.prototype.get = function (k) {\n\t var res = find(this._data, k)\n\t return res && res.value\n\t}\n\t\n\tPseudoMap.prototype.set = function (k, v) {\n\t set(this._data, k, v)\n\t}\n\t\n\tPseudoMap.prototype.delete = function (k) {\n\t var res = find(this._data, k)\n\t if (res) {\n\t delete this._data[res._index]\n\t this._data.size--\n\t }\n\t}\n\t\n\tPseudoMap.prototype.clear = function () {\n\t var data = Object.create(null)\n\t data.size = 0\n\t\n\t Object.defineProperty(this, '_data', {\n\t value: data,\n\t enumerable: false,\n\t configurable: true,\n\t writable: false\n\t })\n\t}\n\t\n\tObject.defineProperty(PseudoMap.prototype, 'size', {\n\t get: function () {\n\t return this._data.size\n\t },\n\t set: function (n) {},\n\t enumerable: true,\n\t configurable: true\n\t})\n\t\n\tPseudoMap.prototype.values =\n\tPseudoMap.prototype.keys =\n\tPseudoMap.prototype.entries = function () {\n\t throw new Error('iterators are not implemented in this version')\n\t}\n\t\n\t// Either identical, or both NaN\n\tfunction same (a, b) {\n\t return a === b || a !== a && b !== b\n\t}\n\t\n\tfunction Entry (k, v, i) {\n\t this.key = k\n\t this.value = v\n\t this._index = i\n\t}\n\t\n\tfunction find (data, k) {\n\t for (var i = 0, s = '_' + k, key = s;\n\t hasOwnProperty.call(data, key);\n\t key = s + i++) {\n\t if (same(data[key].key, k))\n\t return data[key]\n\t }\n\t}\n\t\n\tfunction set (data, k, v) {\n\t for (var i = 0, s = '_' + k, key = s;\n\t hasOwnProperty.call(data, key);\n\t key = s + i++) {\n\t if (same(data[key].key, k)) {\n\t data[key].value = v\n\t return\n\t }\n\t }\n\t data.size++\n\t data[key] = new Entry(k, v, key)\n\t}\n\n\n/***/ },\n/* 44 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.\n\t//\n\t// Permission is hereby granted, free of charge, to any person obtaining a\n\t// copy of this software and associated documentation files (the\n\t// \"Software\"), to deal in the Software without restriction, including\n\t// without limitation the rights to use, copy, modify, merge, publish,\n\t// distribute, sublicense, and/or sell copies of the Software, and to permit\n\t// persons to whom the Software is furnished to do so, subject to the\n\t// following conditions:\n\t//\n\t// The above copyright notice and this permission notice shall be included\n\t// in all copies or substantial portions of the Software.\n\t//\n\t// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n\t// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n\t// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n\t// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n\t// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n\t// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n\t// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\t\n\tvar formatRegExp = /%[sdj%]/g;\n\texports.format = function(f) {\n\t if (!isString(f)) {\n\t var objects = [];\n\t for (var i = 0; i < arguments.length; i++) {\n\t objects.push(inspect(arguments[i]));\n\t }\n\t return objects.join(' ');\n\t }\n\t\n\t var i = 1;\n\t var args = arguments;\n\t var len = args.length;\n\t var str = String(f).replace(formatRegExp, function(x) {\n\t if (x === '%%') return '%';\n\t if (i >= len) return x;\n\t switch (x) {\n\t case '%s': return String(args[i++]);\n\t case '%d': return Number(args[i++]);\n\t case '%j':\n\t try {\n\t return JSON.stringify(args[i++]);\n\t } catch (_) {\n\t return '[Circular]';\n\t }\n\t default:\n\t return x;\n\t }\n\t });\n\t for (var x = args[i]; i < len; x = args[++i]) {\n\t if (isNull(x) || !isObject(x)) {\n\t str += ' ' + x;\n\t } else {\n\t str += ' ' + inspect(x);\n\t }\n\t }\n\t return str;\n\t};\n\t\n\t\n\t// Mark that a method should not be used.\n\t// Returns a modified function which warns once by default.\n\t// If --no-deprecation is set, then it is a no-op.\n\texports.deprecate = function(fn, msg) {\n\t // Allow for deprecating things in the process of starting up.\n\t if (isUndefined(global.process)) {\n\t return function() {\n\t return exports.deprecate(fn, msg).apply(this, arguments);\n\t };\n\t }\n\t\n\t if (process.noDeprecation === true) {\n\t return fn;\n\t }\n\t\n\t var warned = false;\n\t function deprecated() {\n\t if (!warned) {\n\t if (process.throwDeprecation) {\n\t throw new Error(msg);\n\t } else if (process.traceDeprecation) {\n\t console.trace(msg);\n\t } else {\n\t console.error(msg);\n\t }\n\t warned = true;\n\t }\n\t return fn.apply(this, arguments);\n\t }\n\t\n\t return deprecated;\n\t};\n\t\n\t\n\tvar debugs = {};\n\tvar debugEnviron;\n\texports.debuglog = function(set) {\n\t if (isUndefined(debugEnviron))\n\t debugEnviron = process.env.NODE_DEBUG || '';\n\t set = set.toUpperCase();\n\t if (!debugs[set]) {\n\t if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n\t var pid = process.pid;\n\t debugs[set] = function() {\n\t var msg = exports.format.apply(exports, arguments);\n\t console.error('%s %d: %s', set, pid, msg);\n\t };\n\t } else {\n\t debugs[set] = function() {};\n\t }\n\t }\n\t return debugs[set];\n\t};\n\t\n\t\n\t/**\n\t * Echos the value of a value. Trys to print the value out\n\t * in the best way possible given the different types.\n\t *\n\t * @param {Object} obj The object to print out.\n\t * @param {Object} opts Optional options object that alters the output.\n\t */\n\t/* legacy: obj, showHidden, depth, colors*/\n\tfunction inspect(obj, opts) {\n\t // default options\n\t var ctx = {\n\t seen: [],\n\t stylize: stylizeNoColor\n\t };\n\t // legacy...\n\t if (arguments.length >= 3) ctx.depth = arguments[2];\n\t if (arguments.length >= 4) ctx.colors = arguments[3];\n\t if (isBoolean(opts)) {\n\t // legacy...\n\t ctx.showHidden = opts;\n\t } else if (opts) {\n\t // got an \"options\" object\n\t exports._extend(ctx, opts);\n\t }\n\t // set default options\n\t if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n\t if (isUndefined(ctx.depth)) ctx.depth = 2;\n\t if (isUndefined(ctx.colors)) ctx.colors = false;\n\t if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n\t if (ctx.colors) ctx.stylize = stylizeWithColor;\n\t return formatValue(ctx, obj, ctx.depth);\n\t}\n\texports.inspect = inspect;\n\t\n\t\n\t// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\n\tinspect.colors = {\n\t 'bold' : [1, 22],\n\t 'italic' : [3, 23],\n\t 'underline' : [4, 24],\n\t 'inverse' : [7, 27],\n\t 'white' : [37, 39],\n\t 'grey' : [90, 39],\n\t 'black' : [30, 39],\n\t 'blue' : [34, 39],\n\t 'cyan' : [36, 39],\n\t 'green' : [32, 39],\n\t 'magenta' : [35, 39],\n\t 'red' : [31, 39],\n\t 'yellow' : [33, 39]\n\t};\n\t\n\t// Don't use 'blue' not visible on cmd.exe\n\tinspect.styles = {\n\t 'special': 'cyan',\n\t 'number': 'yellow',\n\t 'boolean': 'yellow',\n\t 'undefined': 'grey',\n\t 'null': 'bold',\n\t 'string': 'green',\n\t 'date': 'magenta',\n\t // \"name\": intentionally not styling\n\t 'regexp': 'red'\n\t};\n\t\n\t\n\tfunction stylizeWithColor(str, styleType) {\n\t var style = inspect.styles[styleType];\n\t\n\t if (style) {\n\t return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n\t '\\u001b[' + inspect.colors[style][1] + 'm';\n\t } else {\n\t return str;\n\t }\n\t}\n\t\n\t\n\tfunction stylizeNoColor(str, styleType) {\n\t return str;\n\t}\n\t\n\t\n\tfunction arrayToHash(array) {\n\t var hash = {};\n\t\n\t array.forEach(function(val, idx) {\n\t hash[val] = true;\n\t });\n\t\n\t return hash;\n\t}\n\t\n\t\n\tfunction formatValue(ctx, value, recurseTimes) {\n\t // Provide a hook for user-specified inspect functions.\n\t // Check that value is an object with an inspect function on it\n\t if (ctx.customInspect &&\n\t value &&\n\t isFunction(value.inspect) &&\n\t // Filter out the util module, it's inspect function is special\n\t value.inspect !== exports.inspect &&\n\t // Also filter out any prototype objects using the circular check.\n\t !(value.constructor && value.constructor.prototype === value)) {\n\t var ret = value.inspect(recurseTimes, ctx);\n\t if (!isString(ret)) {\n\t ret = formatValue(ctx, ret, recurseTimes);\n\t }\n\t return ret;\n\t }\n\t\n\t // Primitive types cannot have properties\n\t var primitive = formatPrimitive(ctx, value);\n\t if (primitive) {\n\t return primitive;\n\t }\n\t\n\t // Look up the keys of the object.\n\t var keys = Object.keys(value);\n\t var visibleKeys = arrayToHash(keys);\n\t\n\t if (ctx.showHidden) {\n\t keys = Object.getOwnPropertyNames(value);\n\t }\n\t\n\t // IE doesn't make error fields non-enumerable\n\t // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n\t if (isError(value)\n\t && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n\t return formatError(value);\n\t }\n\t\n\t // Some type of object without properties can be shortcutted.\n\t if (keys.length === 0) {\n\t if (isFunction(value)) {\n\t var name = value.name ? ': ' + value.name : '';\n\t return ctx.stylize('[Function' + name + ']', 'special');\n\t }\n\t if (isRegExp(value)) {\n\t return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n\t }\n\t if (isDate(value)) {\n\t return ctx.stylize(Date.prototype.toString.call(value), 'date');\n\t }\n\t if (isError(value)) {\n\t return formatError(value);\n\t }\n\t }\n\t\n\t var base = '', array = false, braces = ['{', '}'];\n\t\n\t // Make Array say that they are Array\n\t if (isArray(value)) {\n\t array = true;\n\t braces = ['[', ']'];\n\t }\n\t\n\t // Make functions say that they are functions\n\t if (isFunction(value)) {\n\t var n = value.name ? ': ' + value.name : '';\n\t base = ' [Function' + n + ']';\n\t }\n\t\n\t // Make RegExps say that they are RegExps\n\t if (isRegExp(value)) {\n\t base = ' ' + RegExp.prototype.toString.call(value);\n\t }\n\t\n\t // Make dates with properties first say the date\n\t if (isDate(value)) {\n\t base = ' ' + Date.prototype.toUTCString.call(value);\n\t }\n\t\n\t // Make error with message first say the error\n\t if (isError(value)) {\n\t base = ' ' + formatError(value);\n\t }\n\t\n\t if (keys.length === 0 && (!array || value.length == 0)) {\n\t return braces[0] + base + braces[1];\n\t }\n\t\n\t if (recurseTimes < 0) {\n\t if (isRegExp(value)) {\n\t return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n\t } else {\n\t return ctx.stylize('[Object]', 'special');\n\t }\n\t }\n\t\n\t ctx.seen.push(value);\n\t\n\t var output;\n\t if (array) {\n\t output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n\t } else {\n\t output = keys.map(function(key) {\n\t return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n\t });\n\t }\n\t\n\t ctx.seen.pop();\n\t\n\t return reduceToSingleString(output, base, braces);\n\t}\n\t\n\t\n\tfunction formatPrimitive(ctx, value) {\n\t if (isUndefined(value))\n\t return ctx.stylize('undefined', 'undefined');\n\t if (isString(value)) {\n\t var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n\t .replace(/'/g, \"\\\\'\")\n\t .replace(/\\\\\"/g, '\"') + '\\'';\n\t return ctx.stylize(simple, 'string');\n\t }\n\t if (isNumber(value))\n\t return ctx.stylize('' + value, 'number');\n\t if (isBoolean(value))\n\t return ctx.stylize('' + value, 'boolean');\n\t // For some reason typeof null is \"object\", so special case here.\n\t if (isNull(value))\n\t return ctx.stylize('null', 'null');\n\t}\n\t\n\t\n\tfunction formatError(value) {\n\t return '[' + Error.prototype.toString.call(value) + ']';\n\t}\n\t\n\t\n\tfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n\t var output = [];\n\t for (var i = 0, l = value.length; i < l; ++i) {\n\t if (hasOwnProperty(value, String(i))) {\n\t output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n\t String(i), true));\n\t } else {\n\t output.push('');\n\t }\n\t }\n\t keys.forEach(function(key) {\n\t if (!key.match(/^\\d+$/)) {\n\t output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n\t key, true));\n\t }\n\t });\n\t return output;\n\t}\n\t\n\t\n\tfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n\t var name, str, desc;\n\t desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n\t if (desc.get) {\n\t if (desc.set) {\n\t str = ctx.stylize('[Getter/Setter]', 'special');\n\t } else {\n\t str = ctx.stylize('[Getter]', 'special');\n\t }\n\t } else {\n\t if (desc.set) {\n\t str = ctx.stylize('[Setter]', 'special');\n\t }\n\t }\n\t if (!hasOwnProperty(visibleKeys, key)) {\n\t name = '[' + key + ']';\n\t }\n\t if (!str) {\n\t if (ctx.seen.indexOf(desc.value) < 0) {\n\t if (isNull(recurseTimes)) {\n\t str = formatValue(ctx, desc.value, null);\n\t } else {\n\t str = formatValue(ctx, desc.value, recurseTimes - 1);\n\t }\n\t if (str.indexOf('\\n') > -1) {\n\t if (array) {\n\t str = str.split('\\n').map(function(line) {\n\t return ' ' + line;\n\t }).join('\\n').substr(2);\n\t } else {\n\t str = '\\n' + str.split('\\n').map(function(line) {\n\t return ' ' + line;\n\t }).join('\\n');\n\t }\n\t }\n\t } else {\n\t str = ctx.stylize('[Circular]', 'special');\n\t }\n\t }\n\t if (isUndefined(name)) {\n\t if (array && key.match(/^\\d+$/)) {\n\t return str;\n\t }\n\t name = JSON.stringify('' + key);\n\t if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n\t name = name.substr(1, name.length - 2);\n\t name = ctx.stylize(name, 'name');\n\t } else {\n\t name = name.replace(/'/g, \"\\\\'\")\n\t .replace(/\\\\\"/g, '\"')\n\t .replace(/(^\"|\"$)/g, \"'\");\n\t name = ctx.stylize(name, 'string');\n\t }\n\t }\n\t\n\t return name + ': ' + str;\n\t}\n\t\n\t\n\tfunction reduceToSingleString(output, base, braces) {\n\t var numLinesEst = 0;\n\t var length = output.reduce(function(prev, cur) {\n\t numLinesEst++;\n\t if (cur.indexOf('\\n') >= 0) numLinesEst++;\n\t return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n\t }, 0);\n\t\n\t if (length > 60) {\n\t return braces[0] +\n\t (base === '' ? '' : base + '\\n ') +\n\t ' ' +\n\t output.join(',\\n ') +\n\t ' ' +\n\t braces[1];\n\t }\n\t\n\t return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n\t}\n\t\n\t\n\t// NOTE: These type checking functions intentionally don't use `instanceof`\n\t// because it is fragile and can be easily faked with `Object.create()`.\n\tfunction isArray(ar) {\n\t return Array.isArray(ar);\n\t}\n\texports.isArray = isArray;\n\t\n\tfunction isBoolean(arg) {\n\t return typeof arg === 'boolean';\n\t}\n\texports.isBoolean = isBoolean;\n\t\n\tfunction isNull(arg) {\n\t return arg === null;\n\t}\n\texports.isNull = isNull;\n\t\n\tfunction isNullOrUndefined(arg) {\n\t return arg == null;\n\t}\n\texports.isNullOrUndefined = isNullOrUndefined;\n\t\n\tfunction isNumber(arg) {\n\t return typeof arg === 'number';\n\t}\n\texports.isNumber = isNumber;\n\t\n\tfunction isString(arg) {\n\t return typeof arg === 'string';\n\t}\n\texports.isString = isString;\n\t\n\tfunction isSymbol(arg) {\n\t return typeof arg === 'symbol';\n\t}\n\texports.isSymbol = isSymbol;\n\t\n\tfunction isUndefined(arg) {\n\t return arg === void 0;\n\t}\n\texports.isUndefined = isUndefined;\n\t\n\tfunction isRegExp(re) {\n\t return isObject(re) && objectToString(re) === '[object RegExp]';\n\t}\n\texports.isRegExp = isRegExp;\n\t\n\tfunction isObject(arg) {\n\t return typeof arg === 'object' && arg !== null;\n\t}\n\texports.isObject = isObject;\n\t\n\tfunction isDate(d) {\n\t return isObject(d) && objectToString(d) === '[object Date]';\n\t}\n\texports.isDate = isDate;\n\t\n\tfunction isError(e) {\n\t return isObject(e) &&\n\t (objectToString(e) === '[object Error]' || e instanceof Error);\n\t}\n\texports.isError = isError;\n\t\n\tfunction isFunction(arg) {\n\t return typeof arg === 'function';\n\t}\n\texports.isFunction = isFunction;\n\t\n\tfunction isPrimitive(arg) {\n\t return arg === null ||\n\t typeof arg === 'boolean' ||\n\t typeof arg === 'number' ||\n\t typeof arg === 'string' ||\n\t typeof arg === 'symbol' || // ES6 symbol\n\t typeof arg === 'undefined';\n\t}\n\texports.isPrimitive = isPrimitive;\n\t\n\texports.isBuffer = __webpack_require__(45);\n\t\n\tfunction objectToString(o) {\n\t return Object.prototype.toString.call(o);\n\t}\n\t\n\t\n\tfunction pad(n) {\n\t return n < 10 ? '0' + n.toString(10) : n.toString(10);\n\t}\n\t\n\t\n\tvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n\t 'Oct', 'Nov', 'Dec'];\n\t\n\t// 26 Feb 16:19:34\n\tfunction timestamp() {\n\t var d = new Date();\n\t var time = [pad(d.getHours()),\n\t pad(d.getMinutes()),\n\t pad(d.getSeconds())].join(':');\n\t return [d.getDate(), months[d.getMonth()], time].join(' ');\n\t}\n\t\n\t\n\t// log is just a thin wrapper to console.log that prepends a timestamp\n\texports.log = function() {\n\t console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n\t};\n\t\n\t\n\t/**\n\t * Inherit the prototype methods from one constructor into another.\n\t *\n\t * The Function.prototype.inherits from lang.js rewritten as a standalone\n\t * function (not on Function.prototype). NOTE: If this file is to be loaded\n\t * during bootstrapping this function needs to be rewritten using some native\n\t * functions as prototype setup using normal JavaScript does not work as\n\t * expected during bootstrapping (see mirror.js in r114903).\n\t *\n\t * @param {function} ctor Constructor function which needs to inherit the\n\t * prototype.\n\t * @param {function} superCtor Constructor function to inherit prototype from.\n\t */\n\texports.inherits = __webpack_require__(46);\n\t\n\texports._extend = function(origin, add) {\n\t // Don't do anything if add isn't an object\n\t if (!add || !isObject(add)) return origin;\n\t\n\t var keys = Object.keys(add);\n\t var i = keys.length;\n\t while (i--) {\n\t origin[keys[i]] = add[keys[i]];\n\t }\n\t return origin;\n\t};\n\t\n\tfunction hasOwnProperty(obj, prop) {\n\t return Object.prototype.hasOwnProperty.call(obj, prop);\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(42)))\n\n/***/ },\n/* 45 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function isBuffer(arg) {\n\t return arg && typeof arg === 'object'\n\t && typeof arg.copy === 'function'\n\t && typeof arg.fill === 'function'\n\t && typeof arg.readUInt8 === 'function';\n\t}\n\n/***/ },\n/* 46 */\n/***/ function(module, exports) {\n\n\tif (typeof Object.create === 'function') {\n\t // implementation from standard node.js 'util' module\n\t module.exports = function inherits(ctor, superCtor) {\n\t ctor.super_ = superCtor\n\t ctor.prototype = Object.create(superCtor.prototype, {\n\t constructor: {\n\t value: ctor,\n\t enumerable: false,\n\t writable: true,\n\t configurable: true\n\t }\n\t });\n\t };\n\t} else {\n\t // old school shim for old browsers\n\t module.exports = function inherits(ctor, superCtor) {\n\t ctor.super_ = superCtor\n\t var TempCtor = function () {}\n\t TempCtor.prototype = superCtor.prototype\n\t ctor.prototype = new TempCtor()\n\t ctor.prototype.constructor = ctor\n\t }\n\t}\n\n\n/***/ },\n/* 47 */\n/***/ function(module, exports) {\n\n\tmodule.exports = Yallist\n\t\n\tYallist.Node = Node\n\tYallist.create = Yallist\n\t\n\tfunction Yallist (list) {\n\t var self = this\n\t if (!(self instanceof Yallist)) {\n\t self = new Yallist()\n\t }\n\t\n\t self.tail = null\n\t self.head = null\n\t self.length = 0\n\t\n\t if (list && typeof list.forEach === 'function') {\n\t list.forEach(function (item) {\n\t self.push(item)\n\t })\n\t } else if (arguments.length > 0) {\n\t for (var i = 0, l = arguments.length; i < l; i++) {\n\t self.push(arguments[i])\n\t }\n\t }\n\t\n\t return self\n\t}\n\t\n\tYallist.prototype.removeNode = function (node) {\n\t if (node.list !== this) {\n\t throw new Error('removing node which does not belong to this list')\n\t }\n\t\n\t var next = node.next\n\t var prev = node.prev\n\t\n\t if (next) {\n\t next.prev = prev\n\t }\n\t\n\t if (prev) {\n\t prev.next = next\n\t }\n\t\n\t if (node === this.head) {\n\t this.head = next\n\t }\n\t if (node === this.tail) {\n\t this.tail = prev\n\t }\n\t\n\t node.list.length --\n\t node.next = null\n\t node.prev = null\n\t node.list = null\n\t}\n\t\n\tYallist.prototype.unshiftNode = function (node) {\n\t if (node === this.head) {\n\t return\n\t }\n\t\n\t if (node.list) {\n\t node.list.removeNode(node)\n\t }\n\t\n\t var head = this.head\n\t node.list = this\n\t node.next = head\n\t if (head) {\n\t head.prev = node\n\t }\n\t\n\t this.head = node\n\t if (!this.tail) {\n\t this.tail = node\n\t }\n\t this.length ++\n\t}\n\t\n\tYallist.prototype.pushNode = function (node) {\n\t if (node === this.tail) {\n\t return\n\t }\n\t\n\t if (node.list) {\n\t node.list.removeNode(node)\n\t }\n\t\n\t var tail = this.tail\n\t node.list = this\n\t node.prev = tail\n\t if (tail) {\n\t tail.next = node\n\t }\n\t\n\t this.tail = node\n\t if (!this.head) {\n\t this.head = node\n\t }\n\t this.length ++\n\t}\n\t\n\tYallist.prototype.push = function () {\n\t for (var i = 0, l = arguments.length; i < l; i++) {\n\t push(this, arguments[i])\n\t }\n\t return this.length\n\t}\n\t\n\tYallist.prototype.unshift = function () {\n\t for (var i = 0, l = arguments.length; i < l; i++) {\n\t unshift(this, arguments[i])\n\t }\n\t return this.length\n\t}\n\t\n\tYallist.prototype.pop = function () {\n\t if (!this.tail)\n\t return undefined\n\t\n\t var res = this.tail.value\n\t this.tail = this.tail.prev\n\t this.tail.next = null\n\t this.length --\n\t return res\n\t}\n\t\n\tYallist.prototype.shift = function () {\n\t if (!this.head)\n\t return undefined\n\t\n\t var res = this.head.value\n\t this.head = this.head.next\n\t this.head.prev = null\n\t this.length --\n\t return res\n\t}\n\t\n\tYallist.prototype.forEach = function (fn, thisp) {\n\t thisp = thisp || this\n\t for (var walker = this.head, i = 0; walker !== null; i++) {\n\t fn.call(thisp, walker.value, i, this)\n\t walker = walker.next\n\t }\n\t}\n\t\n\tYallist.prototype.forEachReverse = function (fn, thisp) {\n\t thisp = thisp || this\n\t for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {\n\t fn.call(thisp, walker.value, i, this)\n\t walker = walker.prev\n\t }\n\t}\n\t\n\tYallist.prototype.get = function (n) {\n\t for (var i = 0, walker = this.head; walker !== null && i < n; i++) {\n\t // abort out of the list early if we hit a cycle\n\t walker = walker.next\n\t }\n\t if (i === n && walker !== null) {\n\t return walker.value\n\t }\n\t}\n\t\n\tYallist.prototype.getReverse = function (n) {\n\t for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {\n\t // abort out of the list early if we hit a cycle\n\t walker = walker.prev\n\t }\n\t if (i === n && walker !== null) {\n\t return walker.value\n\t }\n\t}\n\t\n\tYallist.prototype.map = function (fn, thisp) {\n\t thisp = thisp || this\n\t var res = new Yallist()\n\t for (var walker = this.head; walker !== null; ) {\n\t res.push(fn.call(thisp, walker.value, this))\n\t walker = walker.next\n\t }\n\t return res\n\t}\n\t\n\tYallist.prototype.mapReverse = function (fn, thisp) {\n\t thisp = thisp || this\n\t var res = new Yallist()\n\t for (var walker = this.tail; walker !== null;) {\n\t res.push(fn.call(thisp, walker.value, this))\n\t walker = walker.prev\n\t }\n\t return res\n\t}\n\t\n\tYallist.prototype.reduce = function (fn, initial) {\n\t var acc\n\t var walker = this.head\n\t if (arguments.length > 1) {\n\t acc = initial\n\t } else if (this.head) {\n\t walker = this.head.next\n\t acc = this.head.value\n\t } else {\n\t throw new TypeError('Reduce of empty list with no initial value')\n\t }\n\t\n\t for (var i = 0; walker !== null; i++) {\n\t acc = fn(acc, walker.value, i)\n\t walker = walker.next\n\t }\n\t\n\t return acc\n\t}\n\t\n\tYallist.prototype.reduceReverse = function (fn, initial) {\n\t var acc\n\t var walker = this.tail\n\t if (arguments.length > 1) {\n\t acc = initial\n\t } else if (this.tail) {\n\t walker = this.tail.prev\n\t acc = this.tail.value\n\t } else {\n\t throw new TypeError('Reduce of empty list with no initial value')\n\t }\n\t\n\t for (var i = this.length - 1; walker !== null; i--) {\n\t acc = fn(acc, walker.value, i)\n\t walker = walker.prev\n\t }\n\t\n\t return acc\n\t}\n\t\n\tYallist.prototype.toArray = function () {\n\t var arr = new Array(this.length)\n\t for (var i = 0, walker = this.head; walker !== null; i++) {\n\t arr[i] = walker.value\n\t walker = walker.next\n\t }\n\t return arr\n\t}\n\t\n\tYallist.prototype.toArrayReverse = function () {\n\t var arr = new Array(this.length)\n\t for (var i = 0, walker = this.tail; walker !== null; i++) {\n\t arr[i] = walker.value\n\t walker = walker.prev\n\t }\n\t return arr\n\t}\n\t\n\tYallist.prototype.slice = function (from, to) {\n\t to = to || this.length\n\t if (to < 0) {\n\t to += this.length\n\t }\n\t from = from || 0\n\t if (from < 0) {\n\t from += this.length\n\t }\n\t var ret = new Yallist()\n\t if (to < from || to < 0) {\n\t return ret\n\t }\n\t if (from < 0) {\n\t from = 0\n\t }\n\t if (to > this.length) {\n\t to = this.length\n\t }\n\t for (var i = 0, walker = this.head; walker !== null && i < from; i++) {\n\t walker = walker.next\n\t }\n\t for (; walker !== null && i < to; i++, walker = walker.next) {\n\t ret.push(walker.value)\n\t }\n\t return ret\n\t}\n\t\n\tYallist.prototype.sliceReverse = function (from, to) {\n\t to = to || this.length\n\t if (to < 0) {\n\t to += this.length\n\t }\n\t from = from || 0\n\t if (from < 0) {\n\t from += this.length\n\t }\n\t var ret = new Yallist()\n\t if (to < from || to < 0) {\n\t return ret\n\t }\n\t if (from < 0) {\n\t from = 0\n\t }\n\t if (to > this.length) {\n\t to = this.length\n\t }\n\t for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {\n\t walker = walker.prev\n\t }\n\t for (; walker !== null && i > from; i--, walker = walker.prev) {\n\t ret.push(walker.value)\n\t }\n\t return ret\n\t}\n\t\n\tYallist.prototype.reverse = function () {\n\t var head = this.head\n\t var tail = this.tail\n\t for (var walker = head; walker !== null; walker = walker.prev) {\n\t var p = walker.prev\n\t walker.prev = walker.next\n\t walker.next = p\n\t }\n\t this.head = tail\n\t this.tail = head\n\t return this\n\t}\n\t\n\tfunction push (self, item) {\n\t self.tail = new Node(item, self.tail, null, self)\n\t if (!self.head) {\n\t self.head = self.tail\n\t }\n\t self.length ++\n\t}\n\t\n\tfunction unshift (self, item) {\n\t self.head = new Node(item, null, self.head, self)\n\t if (!self.tail) {\n\t self.tail = self.head\n\t }\n\t self.length ++\n\t}\n\t\n\tfunction Node (value, prev, next, list) {\n\t if (!(this instanceof Node)) {\n\t return new Node(value, prev, next, list)\n\t }\n\t\n\t this.list = list\n\t this.value = value\n\t\n\t if (prev) {\n\t prev.next = this\n\t this.prev = prev\n\t } else {\n\t this.prev = null\n\t }\n\t\n\t if (next) {\n\t next.prev = this\n\t this.next = next\n\t } else {\n\t this.next = null\n\t }\n\t}\n\n\n/***/ },\n/* 48 */\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 _Tile2 = __webpack_require__(49);\n\t\n\tvar _Tile3 = _interopRequireDefault(_Tile2);\n\t\n\tvar _vendorBoxHelper = __webpack_require__(50);\n\t\n\tvar _vendorBoxHelper2 = _interopRequireDefault(_vendorBoxHelper);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar ImageTile = (function (_Tile) {\n\t _inherits(ImageTile, _Tile);\n\t\n\t function ImageTile(quadcode, path, layer) {\n\t _classCallCheck(this, ImageTile);\n\t\n\t _get(Object.getPrototypeOf(ImageTile.prototype), 'constructor', this).call(this, quadcode, path, layer);\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t // Request data for the tile\n\t\n\t _createClass(ImageTile, [{\n\t key: 'requestTileAsync',\n\t value: function requestTileAsync() {\n\t var _this = this;\n\t\n\t // Making this asynchronous really speeds up the LOD framerate\n\t setTimeout(function () {\n\t if (!_this._mesh) {\n\t _this._mesh = _this._createMesh();\n\t _this._requestTile();\n\t }\n\t }, 0);\n\t }\n\t }, {\n\t key: 'destroy',\n\t value: function destroy() {\n\t // Cancel any pending requests\n\t this._abortRequest();\n\t\n\t // Clear image reference\n\t this._image = null;\n\t\n\t _get(Object.getPrototypeOf(ImageTile.prototype), 'destroy', this).call(this);\n\t }\n\t }, {\n\t key: '_createMesh',\n\t value: function _createMesh() {\n\t // Something went wrong and the tile\n\t //\n\t // Possibly removed by the cache before loaded\n\t if (!this._center) {\n\t return;\n\t }\n\t\n\t var mesh = new _three2['default'].Object3D();\n\t var geom = new _three2['default'].PlaneBufferGeometry(this._side, this._side, 1);\n\t\n\t var material;\n\t if (!this._world._environment._skybox) {\n\t material = new _three2['default'].MeshBasicMaterial({\n\t depthWrite: false\n\t });\n\t\n\t // var material = new THREE.MeshPhongMaterial({\n\t // depthWrite: false\n\t // });\n\t } else {\n\t // Other MeshStandardMaterial settings\n\t //\n\t // material.envMapIntensity will change the amount of colour reflected(?)\n\t // from the environment map – can be greater than 1 for more intensity\n\t\n\t material = new _three2['default'].MeshStandardMaterial({\n\t depthWrite: false\n\t });\n\t material.roughness = 1;\n\t material.metalness = 0.1;\n\t material.envMap = this._world._environment._skybox.getRenderTarget();\n\t }\n\t\n\t var localMesh = new _three2['default'].Mesh(geom, material);\n\t localMesh.rotation.x = -90 * Math.PI / 180;\n\t\n\t localMesh.receiveShadow = true;\n\t\n\t mesh.add(localMesh);\n\t mesh.renderOrder = 0;\n\t\n\t mesh.position.x = this._center[0];\n\t mesh.position.z = this._center[1];\n\t\n\t // var box = new BoxHelper(localMesh);\n\t // mesh.add(box);\n\t //\n\t // mesh.add(this._createDebugMesh());\n\t\n\t return mesh;\n\t }\n\t }, {\n\t key: '_createDebugMesh',\n\t value: function _createDebugMesh() {\n\t var canvas = document.createElement('canvas');\n\t canvas.width = 256;\n\t canvas.height = 256;\n\t\n\t var context = canvas.getContext('2d');\n\t context.font = 'Bold 20px Helvetica Neue, Verdana, Arial';\n\t context.fillStyle = '#ff0000';\n\t context.fillText(this._quadcode, 20, canvas.width / 2 - 5);\n\t context.fillText(this._tile.toString(), 20, canvas.width / 2 + 25);\n\t\n\t var texture = new _three2['default'].Texture(canvas);\n\t\n\t // Silky smooth images when tilted\n\t texture.magFilter = _three2['default'].LinearFilter;\n\t texture.minFilter = _three2['default'].LinearMipMapLinearFilter;\n\t\n\t // TODO: Set this to renderer.getMaxAnisotropy() / 4\n\t texture.anisotropy = 4;\n\t\n\t texture.needsUpdate = true;\n\t\n\t var material = new _three2['default'].MeshBasicMaterial({\n\t map: texture,\n\t transparent: true,\n\t depthWrite: false\n\t });\n\t\n\t var geom = new _three2['default'].PlaneBufferGeometry(this._side, this._side, 1);\n\t var mesh = new _three2['default'].Mesh(geom, material);\n\t\n\t mesh.rotation.x = -90 * Math.PI / 180;\n\t mesh.position.y = 0.1;\n\t\n\t return mesh;\n\t }\n\t }, {\n\t key: '_requestTile',\n\t value: function _requestTile() {\n\t var _this2 = this;\n\t\n\t var urlParams = {\n\t x: this._tile[0],\n\t y: this._tile[1],\n\t z: this._tile[2]\n\t };\n\t\n\t var url = this._getTileURL(urlParams);\n\t\n\t var image = document.createElement('img');\n\t\n\t image.addEventListener('load', function (event) {\n\t var texture = new _three2['default'].Texture();\n\t\n\t texture.image = image;\n\t texture.needsUpdate = true;\n\t\n\t // Silky smooth images when tilted\n\t texture.magFilter = _three2['default'].LinearFilter;\n\t texture.minFilter = _three2['default'].LinearMipMapLinearFilter;\n\t\n\t // TODO: Set this to renderer.getMaxAnisotropy() / 4\n\t texture.anisotropy = 4;\n\t\n\t texture.needsUpdate = true;\n\t\n\t // Something went wrong and the tile or its material is missing\n\t //\n\t // Possibly removed by the cache before the image loaded\n\t if (!_this2._mesh || !_this2._mesh.children[0] || !_this2._mesh.children[0].material) {\n\t return;\n\t }\n\t\n\t _this2._mesh.children[0].material.map = texture;\n\t _this2._mesh.children[0].material.needsUpdate = true;\n\t\n\t _this2._texture = texture;\n\t _this2._ready = true;\n\t }, false);\n\t\n\t // image.addEventListener('progress', event => {}, false);\n\t // image.addEventListener('error', event => {}, false);\n\t\n\t image.crossOrigin = '';\n\t\n\t // Load image\n\t image.src = url;\n\t\n\t this._image = image;\n\t }\n\t }, {\n\t key: '_abortRequest',\n\t value: function _abortRequest() {\n\t if (!this._image) {\n\t return;\n\t }\n\t\n\t this._image.src = '';\n\t }\n\t }]);\n\t\n\t return ImageTile;\n\t})(_Tile3['default']);\n\t\n\texports['default'] = function (quadcode, path, layer) {\n\t return new ImageTile(quadcode, path, layer);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 49 */\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 _geoPoint = __webpack_require__(11);\n\t\n\tvar _geoPoint2 = _interopRequireDefault(_geoPoint);\n\t\n\tvar _geoLatLon = __webpack_require__(10);\n\t\n\tvar _geoLatLon2 = _interopRequireDefault(_geoLatLon);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t// Manages a single tile and its layers\n\t\n\tvar r2d = 180 / Math.PI;\n\t\n\tvar tileURLRegex = /\\{([szxy])\\}/g;\n\t\n\tvar Tile = (function () {\n\t function Tile(quadcode, path, layer) {\n\t _classCallCheck(this, Tile);\n\t\n\t this._layer = layer;\n\t this._world = layer._world;\n\t this._quadcode = quadcode;\n\t this._path = path;\n\t\n\t this._ready = false;\n\t\n\t this._tile = this._quadcodeToTile(quadcode);\n\t\n\t // Bottom-left and top-right bounds in WGS84 coordinates\n\t this._boundsLatLon = this._tileBoundsWGS84(this._tile);\n\t\n\t // Bottom-left and top-right bounds in world coordinates\n\t this._boundsWorld = this._tileBoundsFromWGS84(this._boundsLatLon);\n\t\n\t // Tile center in world coordinates\n\t this._center = this._boundsToCenter(this._boundsWorld);\n\t\n\t // Tile center in projected coordinates\n\t this._centerLatlon = this._world.pointToLatLon(VIZI.Point(this._center[0], this._center[1]));\n\t\n\t // Length of a tile side in world coorindates\n\t this._side = this._getSide(this._boundsWorld);\n\t\n\t // Point scale for tile (for unit conversion)\n\t this._pointScale = this._world.pointScale(this._centerLatlon);\n\t }\n\t\n\t // Returns true if the tile mesh and texture are ready to be used\n\t // Otherwise, returns false\n\t\n\t _createClass(Tile, [{\n\t key: 'isReady',\n\t value: function isReady() {\n\t return this._ready;\n\t }\n\t\n\t // Request data for the tile\n\t }, {\n\t key: 'requestTileAsync',\n\t value: function requestTileAsync() {}\n\t }, {\n\t key: 'getQuadcode',\n\t value: function getQuadcode() {\n\t return this._quadcode;\n\t }\n\t }, {\n\t key: 'getBounds',\n\t value: function getBounds() {\n\t return this._boundsWorld;\n\t }\n\t }, {\n\t key: 'getCenter',\n\t value: function getCenter() {\n\t return this._center;\n\t }\n\t }, {\n\t key: 'getSide',\n\t value: function getSide() {\n\t return this._side;\n\t }\n\t }, {\n\t key: 'getMesh',\n\t value: function getMesh() {\n\t return this._mesh;\n\t }\n\t\n\t // Destroys the tile and removes it from the layer and memory\n\t //\n\t // Ensure that this leaves no trace of the tile – no textures, no meshes,\n\t // nothing in memory or the GPU\n\t }, {\n\t key: 'destroy',\n\t value: function destroy() {\n\t // Delete reference to layer and world\n\t this._layer = null;\n\t this._world = null;\n\t\n\t // Delete location references\n\t this._boundsLatLon = null;\n\t this._boundsWorld = null;\n\t this._center = null;\n\t\n\t // Done if no mesh\n\t if (!this._mesh) {\n\t return;\n\t }\n\t\n\t if (this._mesh.children) {\n\t // Dispose of mesh and materials\n\t this._mesh.children.forEach(function (child) {\n\t child.geometry.dispose();\n\t child.geometry = null;\n\t\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 } else {\n\t this._mesh.geometry.dispose();\n\t this._mesh.geometry = null;\n\t\n\t if (this._mesh.material.map) {\n\t this._mesh.material.map.dispose();\n\t this._mesh.material.map = null;\n\t }\n\t\n\t this._mesh.material.dispose();\n\t this._mesh.material = null;\n\t }\n\t }\n\t }, {\n\t key: '_createMesh',\n\t value: function _createMesh() {}\n\t }, {\n\t key: '_createDebugMesh',\n\t value: function _createDebugMesh() {}\n\t }, {\n\t key: '_getTileURL',\n\t value: function _getTileURL(urlParams) {\n\t if (!urlParams.s) {\n\t // Default to a random choice of a, b or c\n\t urlParams.s = String.fromCharCode(97 + Math.floor(Math.random() * 3));\n\t }\n\t\n\t tileURLRegex.lastIndex = 0;\n\t return this._path.replace(tileURLRegex, function (value, key) {\n\t // Replace with paramter, otherwise keep existing value\n\t return urlParams[key];\n\t });\n\t }\n\t\n\t // Convert from quadcode to TMS tile coordinates\n\t }, {\n\t key: '_quadcodeToTile',\n\t value: function _quadcodeToTile(quadcode) {\n\t var x = 0;\n\t var y = 0;\n\t var z = quadcode.length;\n\t\n\t for (var i = z; i > 0; i--) {\n\t var mask = 1 << i - 1;\n\t var q = +quadcode[z - i];\n\t if (q === 1) {\n\t x |= mask;\n\t }\n\t if (q === 2) {\n\t y |= mask;\n\t }\n\t if (q === 3) {\n\t x |= mask;\n\t y |= mask;\n\t }\n\t }\n\t\n\t return [x, y, z];\n\t }\n\t\n\t // Convert WGS84 tile bounds to world coordinates\n\t }, {\n\t key: '_tileBoundsFromWGS84',\n\t value: function _tileBoundsFromWGS84(boundsWGS84) {\n\t var sw = this._layer._world.latLonToPoint((0, _geoLatLon2['default'])(boundsWGS84[1], boundsWGS84[0]));\n\t var ne = this._layer._world.latLonToPoint((0, _geoLatLon2['default'])(boundsWGS84[3], boundsWGS84[2]));\n\t\n\t return [sw.x, sw.y, ne.x, ne.y];\n\t }\n\t\n\t // Get tile bounds in WGS84 coordinates\n\t }, {\n\t key: '_tileBoundsWGS84',\n\t value: function _tileBoundsWGS84(tile) {\n\t var e = this._tile2lon(tile[0] + 1, tile[2]);\n\t var w = this._tile2lon(tile[0], tile[2]);\n\t var s = this._tile2lat(tile[1] + 1, tile[2]);\n\t var n = this._tile2lat(tile[1], tile[2]);\n\t return [w, s, e, n];\n\t }\n\t }, {\n\t key: '_tile2lon',\n\t value: function _tile2lon(x, z) {\n\t return x / Math.pow(2, z) * 360 - 180;\n\t }\n\t }, {\n\t key: '_tile2lat',\n\t value: function _tile2lat(y, z) {\n\t var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);\n\t return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));\n\t }\n\t }, {\n\t key: '_boundsToCenter',\n\t value: function _boundsToCenter(bounds) {\n\t var x = bounds[0] + (bounds[2] - bounds[0]) / 2;\n\t var y = bounds[1] + (bounds[3] - bounds[1]) / 2;\n\t\n\t return [x, y];\n\t }\n\t }, {\n\t key: '_getSide',\n\t value: function _getSide(bounds) {\n\t return new _three2['default'].Vector3(bounds[0], 0, bounds[3]).sub(new _three2['default'].Vector3(bounds[0], 0, bounds[1])).length();\n\t }\n\t }]);\n\t\n\t return Tile;\n\t})();\n\t\n\texports['default'] = Tile;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 50 */\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 eqeqeq:0*/\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\t/**\n\t * @author mrdoob / http://mrdoob.com/\n\t */\n\t\n\tBoxHelper = function (object) {\n\t\n\t\tvar indices = new Uint16Array([0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7]);\n\t\tvar positions = new Float32Array(8 * 3);\n\t\n\t\tvar geometry = new _three2['default'].BufferGeometry();\n\t\tgeometry.setIndex(new _three2['default'].BufferAttribute(indices, 1));\n\t\tgeometry.addAttribute('position', new _three2['default'].BufferAttribute(positions, 3));\n\t\n\t\t_three2['default'].LineSegments.call(this, geometry, new _three2['default'].LineBasicMaterial({ linewidth: 2, color: 0xff0000 }));\n\t\n\t\tif (object !== undefined) {\n\t\n\t\t\tthis.update(object);\n\t\t}\n\t};\n\t\n\tBoxHelper.prototype = Object.create(_three2['default'].LineSegments.prototype);\n\tBoxHelper.prototype.constructor = BoxHelper;\n\t\n\tBoxHelper.prototype.update = (function () {\n\t\n\t\tvar box = new _three2['default'].Box3();\n\t\n\t\treturn function (object) {\n\t\n\t\t\tbox.setFromObject(object);\n\t\n\t\t\tif (box.isEmpty()) return;\n\t\n\t\t\tvar min = box.min;\n\t\t\tvar max = box.max;\n\t\n\t\t\t/*\n\t 5____4\n\t 1/___0/|\n\t | 6__|_7\n\t 2/___3/\n\t \t0: max.x, max.y, max.z\n\t 1: min.x, max.y, max.z\n\t 2: min.x, min.y, max.z\n\t 3: max.x, min.y, max.z\n\t 4: max.x, max.y, min.z\n\t 5: min.x, max.y, min.z\n\t 6: min.x, min.y, min.z\n\t 7: max.x, min.y, min.z\n\t */\n\t\n\t\t\tvar position = this.geometry.attributes.position;\n\t\t\tvar array = position.array;\n\t\n\t\t\tarray[0] = max.x;array[1] = max.y;array[2] = max.z;\n\t\t\tarray[3] = min.x;array[4] = max.y;array[5] = max.z;\n\t\t\tarray[6] = min.x;array[7] = min.y;array[8] = max.z;\n\t\t\tarray[9] = max.x;array[10] = min.y;array[11] = max.z;\n\t\t\tarray[12] = max.x;array[13] = max.y;array[14] = min.z;\n\t\t\tarray[15] = min.x;array[16] = max.y;array[17] = min.z;\n\t\t\tarray[18] = min.x;array[19] = min.y;array[20] = min.z;\n\t\t\tarray[21] = max.x;array[22] = min.y;array[23] = min.z;\n\t\n\t\t\tposition.needsUpdate = true;\n\t\n\t\t\tthis.geometry.computeBoundingSphere();\n\t\t};\n\t})();\n\t\n\texports['default'] = BoxHelper;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 51 */\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__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\texports['default'] = function (colour, skyboxTarget) {\n\t var canvas = document.createElement('canvas');\n\t canvas.width = 1;\n\t canvas.height = 1;\n\t\n\t var context = canvas.getContext('2d');\n\t context.fillStyle = colour;\n\t context.fillRect(0, 0, canvas.width, canvas.height);\n\t // context.strokeStyle = '#D0D0CF';\n\t // context.strokeRect(0, 0, canvas.width, canvas.height);\n\t\n\t var texture = new _three2['default'].Texture(canvas);\n\t\n\t // // Silky smooth images when tilted\n\t // texture.magFilter = THREE.LinearFilter;\n\t // texture.minFilter = THREE.LinearMipMapLinearFilter;\n\t // //\n\t // // // TODO: Set this to renderer.getMaxAnisotropy() / 4\n\t // texture.anisotropy = 4;\n\t\n\t // texture.wrapS = THREE.RepeatWrapping;\n\t // texture.wrapT = THREE.RepeatWrapping;\n\t // texture.repeat.set(segments, segments);\n\t\n\t texture.needsUpdate = true;\n\t\n\t var material;\n\t\n\t if (!skyboxTarget) {\n\t material = new _three2['default'].MeshBasicMaterial({\n\t map: texture,\n\t depthWrite: false\n\t });\n\t } else {\n\t material = new _three2['default'].MeshStandardMaterial({\n\t depthWrite: false\n\t });\n\t material.roughness = 1;\n\t material.metalness = 0.1;\n\t material.envMap = skyboxTarget;\n\t }\n\t\n\t return material;\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 52 */\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 _TileLayer2 = __webpack_require__(38);\n\t\n\tvar _TileLayer3 = _interopRequireDefault(_TileLayer2);\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _TopoJSONTile = __webpack_require__(53);\n\t\n\tvar _TopoJSONTile2 = _interopRequireDefault(_TopoJSONTile);\n\t\n\tvar _lodashThrottle = __webpack_require__(35);\n\t\n\tvar _lodashThrottle2 = _interopRequireDefault(_lodashThrottle);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar TopoJSONTileLayer = (function (_TileLayer) {\n\t _inherits(TopoJSONTileLayer, _TileLayer);\n\t\n\t function TopoJSONTileLayer(path, options) {\n\t _classCallCheck(this, TopoJSONTileLayer);\n\t\n\t var defaults = {\n\t maxLOD: 14,\n\t distance: 2000\n\t };\n\t\n\t options = (0, _lodashAssign2['default'])(defaults, options);\n\t\n\t _get(Object.getPrototypeOf(TopoJSONTileLayer.prototype), 'constructor', this).call(this, options);\n\t\n\t this._path = path;\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t _createClass(TopoJSONTileLayer, [{\n\t key: '_onAdd',\n\t value: function _onAdd(world) {\n\t var _this = this;\n\t\n\t _get(Object.getPrototypeOf(TopoJSONTileLayer.prototype), '_onAdd', this).call(this, world);\n\t\n\t // Trigger initial quadtree calculation on the next frame\n\t //\n\t // TODO: This is a hack to ensure the camera is all set up - a better\n\t // solution should be found\n\t setTimeout(function () {\n\t _this._calculateLOD();\n\t _this._initEvents();\n\t }, 0);\n\t }\n\t }, {\n\t key: '_initEvents',\n\t value: function _initEvents() {\n\t // Run LOD calculations based on render calls\n\t //\n\t // Throttled to 1 LOD calculation per 100ms\n\t this._throttledWorldUpdate = (0, _lodashThrottle2['default'])(this._onWorldUpdate, 100);\n\t\n\t this._world.on('preUpdate', this._throttledWorldUpdate, this);\n\t this._world.on('move', this._onWorldMove, this);\n\t }\n\t }, {\n\t key: '_onWorldUpdate',\n\t value: function _onWorldUpdate() {\n\t this._calculateLOD();\n\t }\n\t }, {\n\t key: '_onWorldMove',\n\t value: function _onWorldMove(latlon, point) {}\n\t }, {\n\t key: '_createTile',\n\t value: function _createTile(quadcode, layer) {\n\t var options = {};\n\t\n\t if (this._options.filter) {\n\t options.filter = this._options.filter;\n\t }\n\t\n\t if (this._options.style) {\n\t options.style = this._options.style;\n\t }\n\t\n\t return (0, _TopoJSONTile2['default'])(quadcode, this._path, layer, options);\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 this._world.off('preUpdate', this._throttledWorldUpdate);\n\t this._world.off('move', this._onWorldMove);\n\t\n\t this._throttledWorldUpdate = null;\n\t\n\t // Run common destruction logic from parent\n\t _get(Object.getPrototypeOf(TopoJSONTileLayer.prototype), 'destroy', this).call(this);\n\t }\n\t }]);\n\t\n\t return TopoJSONTileLayer;\n\t})(_TileLayer3['default']);\n\t\n\texports['default'] = function (path, options) {\n\t return new TopoJSONTileLayer(path, options);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 53 */\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 _Tile2 = __webpack_require__(49);\n\t\n\tvar _Tile3 = _interopRequireDefault(_Tile2);\n\t\n\tvar _vendorBoxHelper = __webpack_require__(50);\n\t\n\tvar _vendorBoxHelper2 = _interopRequireDefault(_vendorBoxHelper);\n\t\n\tvar _three = __webpack_require__(24);\n\t\n\tvar _three2 = _interopRequireDefault(_three);\n\t\n\tvar _reqwest = __webpack_require__(54);\n\t\n\tvar _reqwest2 = _interopRequireDefault(_reqwest);\n\t\n\tvar _topojson = __webpack_require__(56);\n\t\n\tvar _topojson2 = _interopRequireDefault(_topojson);\n\t\n\tvar _geoPoint = __webpack_require__(11);\n\t\n\tvar _geoPoint2 = _interopRequireDefault(_geoPoint);\n\t\n\tvar _geoLatLon = __webpack_require__(10);\n\t\n\tvar _geoLatLon2 = _interopRequireDefault(_geoLatLon);\n\t\n\tvar _earcut = __webpack_require__(57);\n\t\n\tvar _earcut2 = _interopRequireDefault(_earcut);\n\t\n\tvar _lodashAssign = __webpack_require__(3);\n\t\n\tvar _lodashAssign2 = _interopRequireDefault(_lodashAssign);\n\t\n\tvar _utilExtrudePolygon = __webpack_require__(58);\n\t\n\tvar _utilExtrudePolygon2 = _interopRequireDefault(_utilExtrudePolygon);\n\t\n\tvar _polygonOffset = __webpack_require__(59);\n\t\n\tvar _polygonOffset2 = _interopRequireDefault(_polygonOffset);\n\t\n\t// TODO: Perform tile request and processing in a Web Worker\n\t//\n\t// Use Operative (https://github.com/padolsey/operative)\n\t//\n\t// Would it make sense to have the worker functionality defined in a static\n\t// method so it only gets initialised once and not on every tile instance?\n\t//\n\t// Otherwise, worker processing logic would have to go in the tile layer so not\n\t// to waste loads of time setting up a brand new worker with three.js for each\n\t// tile every single time.\n\t//\n\t// Unsure of the best way to get three.js and VIZI into the worker\n\t//\n\t// Would need to set up a CRS / projection identical to the world instance\n\t//\n\t// Is it possible to bypass requirements on external script by having multiple\n\t// simple worker methods that each take enough inputs to perform a single task\n\t// without requiring VIZI or three.js? So long as the heaviest logic is done in\n\t// the worker and transferrable objects are used then it should be better than\n\t// nothing. Would probably still need things like earcut...\n\t//\n\t// After all, the three.js logic and object creation will still need to be\n\t// done on the main thread regardless so the worker should try to do as much as\n\t// possible with as few dependencies as possible.\n\t//\n\t// Have a look at how this is done in Tangram before implementing anything as\n\t// the approach there is pretty similar and robust.\n\t\n\tvar TopoJSONTile = (function (_Tile) {\n\t _inherits(TopoJSONTile, _Tile);\n\t\n\t function TopoJSONTile(quadcode, path, layer, options) {\n\t _classCallCheck(this, TopoJSONTile);\n\t\n\t _get(Object.getPrototypeOf(TopoJSONTile.prototype), 'constructor', this).call(this, quadcode, path, layer);\n\t\n\t var defaults = {\n\t filter: null,\n\t style: {\n\t color: '#ffffff'\n\t }\n\t };\n\t\n\t this._options = (0, _lodashAssign2['default'])(defaults, options);\n\t }\n\t\n\t // Initialise without requiring new keyword\n\t\n\t // Request data for the tile\n\t\n\t _createClass(TopoJSONTile, [{\n\t key: 'requestTileAsync',\n\t value: function requestTileAsync() {\n\t var _this = this;\n\t\n\t // Making this asynchronous really speeds up the LOD framerate\n\t setTimeout(function () {\n\t if (!_this._mesh) {\n\t _this._mesh = _this._createMesh();\n\t // this._shadowCanvas = this._createShadowCanvas();\n\t _this._requestTile();\n\t }\n\t }, 0);\n\t }\n\t }, {\n\t key: 'destroy',\n\t value: function destroy() {\n\t // Cancel any pending requests\n\t this._abortRequest();\n\t\n\t // Clear request reference\n\t this._request = null;\n\t\n\t _get(Object.getPrototypeOf(TopoJSONTile.prototype), 'destroy', this).call(this);\n\t }\n\t }, {\n\t key: '_createMesh',\n\t value: function _createMesh() {\n\t // Something went wrong and the tile\n\t //\n\t // Possibly removed by the cache before loaded\n\t if (!this._center) {\n\t return;\n\t }\n\t\n\t var mesh = new _three2['default'].Object3D();\n\t\n\t mesh.position.x = this._center[0];\n\t mesh.position.z = this._center[1];\n\t\n\t // var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n\t //\n\t // var material = new THREE.MeshBasicMaterial({\n\t // depthWrite: false\n\t // });\n\t //\n\t // var localMesh = new THREE.Mesh(geom, material);\n\t // localMesh.rotation.x = -90 * Math.PI / 180;\n\t //\n\t // mesh.add(localMesh);\n\t //\n\t // var box = new BoxHelper(localMesh);\n\t // mesh.add(box);\n\t //\n\t // mesh.add(this._createDebugMesh());\n\t\n\t return mesh;\n\t }\n\t }, {\n\t key: '_createDebugMesh',\n\t value: function _createDebugMesh() {\n\t var canvas = document.createElement('canvas');\n\t canvas.width = 256;\n\t canvas.height = 256;\n\t\n\t var context = canvas.getContext('2d');\n\t context.font = 'Bold 20px Helvetica Neue, Verdana, Arial';\n\t context.fillStyle = '#ff0000';\n\t context.fillText(this._quadcode, 20, canvas.width / 2 - 5);\n\t context.fillText(this._tile.toString(), 20, canvas.width / 2 + 25);\n\t\n\t var texture = new _three2['default'].Texture(canvas);\n\t\n\t // Silky smooth images when tilted\n\t texture.magFilter = _three2['default'].LinearFilter;\n\t texture.minFilter = _three2['default'].LinearMipMapLinearFilter;\n\t\n\t // TODO: Set this to renderer.getMaxAnisotropy() / 4\n\t texture.anisotropy = 4;\n\t\n\t texture.needsUpdate = true;\n\t\n\t var material = new _three2['default'].MeshBasicMaterial({\n\t map: texture,\n\t transparent: true,\n\t depthWrite: false\n\t });\n\t\n\t var geom = new _three2['default'].PlaneBufferGeometry(this._side, this._side, 1);\n\t var mesh = new _three2['default'].Mesh(geom, material);\n\t\n\t mesh.rotation.x = -90 * Math.PI / 180;\n\t mesh.position.y = 0.1;\n\t\n\t return mesh;\n\t }\n\t }, {\n\t key: '_createShadowCanvas',\n\t value: function _createShadowCanvas() {\n\t var canvas = document.createElement('canvas');\n\t\n\t // Rendered at a low resolution and later scaled up for a low-quality blur\n\t canvas.width = 512;\n\t canvas.height = 512;\n\t\n\t return canvas;\n\t }\n\t }, {\n\t key: '_addShadow',\n\t value: function _addShadow(coordinates) {\n\t var _this2 = this;\n\t\n\t var ctx = this._shadowCanvas.getContext('2d');\n\t var width = this._shadowCanvas.width;\n\t var height = this._shadowCanvas.height;\n\t\n\t var _coords;\n\t var _offset;\n\t var offset = new _polygonOffset2['default']();\n\t\n\t // Transform coordinates to shadowCanvas space and draw on canvas\n\t coordinates.forEach(function (ring, index) {\n\t ctx.beginPath();\n\t\n\t _coords = ring.map(function (coord) {\n\t var xFrac = (coord[0] - _this2._boundsWorld[0]) / _this2._side;\n\t var yFrac = (coord[1] - _this2._boundsWorld[3]) / _this2._side;\n\t return [xFrac * width, yFrac * height];\n\t });\n\t\n\t if (index > 0) {\n\t _offset = _coords;\n\t } else {\n\t _offset = offset.data(_coords).padding(1.3);\n\t }\n\t\n\t // TODO: This is super flaky and crashes the browser if run on anything\n\t // put the outer ring (potentially due to winding)\n\t _offset.forEach(function (coord, index) {\n\t // var xFrac = (coord[0] - this._boundsWorld[0]) / this._side;\n\t // var yFrac = (coord[1] - this._boundsWorld[3]) / this._side;\n\t\n\t if (index === 0) {\n\t ctx.moveTo(coord[0], coord[1]);\n\t } else {\n\t ctx.lineTo(coord[0], coord[1]);\n\t }\n\t });\n\t\n\t ctx.closePath();\n\t });\n\t\n\t ctx.fillStyle = 'rgba(80, 80, 80, 0.7)';\n\t ctx.fill();\n\t }\n\t }, {\n\t key: '_requestTile',\n\t value: function _requestTile() {\n\t var _this3 = this;\n\t\n\t var urlParams = {\n\t x: this._tile[0],\n\t y: this._tile[1],\n\t z: this._tile[2]\n\t };\n\t\n\t var url = this._getTileURL(urlParams);\n\t\n\t this._request = (0, _reqwest2['default'])({\n\t url: url,\n\t type: 'json',\n\t crossOrigin: true\n\t }).then(function (res) {\n\t // Clear request reference\n\t _this3._request = null;\n\t _this3._processTileData(res);\n\t })['catch'](function (err) {\n\t console.error(err);\n\t\n\t // Clear request reference\n\t _this3._request = null;\n\t });\n\t }\n\t }, {\n\t key: '_processTileData',\n\t value: function _processTileData(data) {\n\t var _this4 = this;\n\t\n\t console.time(this._tile);\n\t\n\t var geojson = _topojson2['default'].feature(data, data.objects.vectile);\n\t\n\t var offset = (0, _geoPoint2['default'])(0, 0);\n\t offset.x = -1 * this._center[0];\n\t offset.y = -1 * this._center[1];\n\t\n\t var coordinates;\n\t var earcutData;\n\t var faces;\n\t\n\t var allVertices = [];\n\t var allFaces = [];\n\t var allColours = [];\n\t var facesCount = 0;\n\t\n\t var colour = new _three2['default'].Color();\n\t\n\t var light = new _three2['default'].Color(0xffffff);\n\t var shadow = new _three2['default'].Color(0x666666);\n\t\n\t var features = geojson.features;\n\t\n\t // Run filter, if provided\n\t if (this._options.filter) {\n\t features = geojson.features.filter(this._options.filter);\n\t }\n\t\n\t var style = this._options.style;\n\t\n\t features.forEach(function (feature) {\n\t // feature.geometry, feature.properties\n\t\n\t // Get style object, if provided\n\t if (typeof _this4._options.style === 'function') {\n\t style = _this4._options.style(feature);\n\t }\n\t\n\t var coordinates = feature.geometry.coordinates;\n\t\n\t // Skip if geometry is a point\n\t //\n\t // This should be a user-defined filter as it would be wrong to assume\n\t // that people won't want to output points\n\t //\n\t // The default use-case should be to output points in a different way\n\t if (!coordinates[0] || !coordinates[0][0] || !Array.isArray(coordinates[0][0])) {\n\t return;\n\t }\n\t\n\t coordinates = coordinates.map(function (ring) {\n\t return ring.map(function (coordinate) {\n\t var latlon = (0, _geoLatLon2['default'])(coordinate[1], coordinate[0]);\n\t var point = _this4._layer._world.latLonToPoint(latlon);\n\t return [point.x, point.y];\n\t });\n\t });\n\t\n\t // Draw footprint on shadow canvas\n\t //\n\t // TODO: Disabled for the time-being until it can be sped up / moved to\n\t // a worker\n\t // this._addShadow(coordinates);\n\t\n\t earcutData = _this4._toEarcut(coordinates);\n\t\n\t faces = _this4._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 height = 0;\n\t\n\t if (style.height) {\n\t height = _this4._world.metresToWorld(style.height, _this4._pointScale);\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 colour.set(style.color);\n\t\n\t var topColor = colour.clone().multiply(light);\n\t var bottomColor = colour.clone().multiply(shadow);\n\t\n\t var _faces = [];\n\t var _colours = [];\n\t\n\t allVertices.push(extruded.positions);\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 // 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 // Skip bottom as there's no point rendering it\n\t // allFaces.push(extruded.faces);\n\t\n\t allFaces.push(_faces);\n\t allColours.push(_colours);\n\t\n\t facesCount += _faces.length;\n\t });\n\t\n\t // Output shadow canvas\n\t //\n\t // TODO: Disabled for the time-being until it can be sped up / moved to\n\t // a worker\n\t\n\t // var texture = new THREE.Texture(this._shadowCanvas);\n\t //\n\t // // Silky smooth images when tilted\n\t // texture.magFilter = THREE.LinearFilter;\n\t // texture.minFilter = THREE.LinearMipMapLinearFilter;\n\t //\n\t // // TODO: Set this to renderer.getMaxAnisotropy() / 4\n\t // texture.anisotropy = 4;\n\t //\n\t // texture.needsUpdate = true;\n\t //\n\t // var material;\n\t // if (!this._world._environment._skybox) {\n\t // material = new THREE.MeshBasicMaterial({\n\t // map: texture,\n\t // transparent: true,\n\t // depthWrite: false\n\t // });\n\t // } else {\n\t // material = new THREE.MeshStandardMaterial({\n\t // map: texture,\n\t // transparent: true,\n\t // depthWrite: false\n\t // });\n\t // material.roughness = 1;\n\t // material.metalness = 0.1;\n\t // material.envMap = this._world._environment._skybox.getRenderTarget();\n\t // }\n\t //\n\t // var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n\t // var mesh = new THREE.Mesh(geom, material);\n\t //\n\t // mesh.castShadow = false;\n\t // mesh.receiveShadow = false;\n\t // mesh.renderOrder = 1;\n\t //\n\t // mesh.rotation.x = -90 * Math.PI / 180;\n\t //\n\t // this._mesh.add(mesh);\n\t\n\t // Skip if no faces\n\t //\n\t // Need to check way before this if there are no faces, before even doing\n\t // earcut triangulation.\n\t if (facesCount === 0) {\n\t this._ready = true;\n\t return;\n\t }\n\t\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(facesCount * 9);\n\t var normals = new Float32Array(facesCount * 9);\n\t var colours = new Float32Array(facesCount * 9);\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 dim = 2;\n\t\n\t var index;\n\t var _faces;\n\t var _vertices;\n\t var _colour;\n\t var lastIndex = 0;\n\t for (var i = 0; i < allFaces.length; i++) {\n\t _faces = allFaces[i];\n\t _vertices = allVertices[i];\n\t _colour = allColours[i];\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 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 geometry.computeBoundingBox();\n\t\n\t var material;\n\t if (!this._world._environment._skybox) {\n\t material = new _three2['default'].MeshPhongMaterial({\n\t vertexColors: _three2['default'].VertexColors,\n\t side: _three2['default'].BackSide\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 });\n\t material.roughness = 1;\n\t material.metalness = 0.1;\n\t material.envMapIntensity = 3;\n\t material.envMap = this._world._environment._skybox.getRenderTarget();\n\t }\n\t\n\t var mesh = new _three2['default'].Mesh(geometry, material);\n\t\n\t mesh.castShadow = true;\n\t mesh.receiveShadow = true;\n\t\n\t // This is only useful for flat objects\n\t // mesh.renderOrder = 1;\n\t\n\t this._mesh.add(mesh);\n\t\n\t this._ready = true;\n\t console.timeEnd(this._tile);\n\t console.log(this._tile + ': ' + features.length + ' features');\n\t }\n\t }, {\n\t key: '_toEarcut',\n\t value: 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 key: '_triangulate',\n\t value: 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 key: '_abortRequest',\n\t value: function _abortRequest() {\n\t if (!this._request) {\n\t return;\n\t }\n\t\n\t this._request.abort();\n\t }\n\t }]);\n\t\n\t return TopoJSONTile;\n\t})(_Tile3['default']);\n\t\n\texports['default'] = function (quadcode, path, layer, options) {\n\t return new TopoJSONTile(quadcode, path, layer, options);\n\t};\n\t\n\t;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 54 */\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__(55)\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/* 55 */\n/***/ function(module, exports) {\n\n\t/* (ignored) */\n\n/***/ },\n/* 56 */\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 = {})));\n\t}(this, function (exports) { 'use strict';\n\t\n\t function noop() {}\n\t\n\t function absolute(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\t function relative(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 = (point[0] - dx) / kx | 0,\n\t y1 = (point[1] - dy) / ky | 0;\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\t function 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\t function 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\t function 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\t function 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\t function object(topology, o) {\n\t var absolute$$ = absolute(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\t function 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\t function mesh(topology) {\n\t return object(topology, meshArcs.apply(this, arguments));\n\t }\n\t\n\t function 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\t function triangle(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\t function 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\t function merge(topology) {\n\t return object(topology, mergeArcs.apply(this, arguments));\n\t }\n\t\n\t function 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 exterior(ring$$) {\n\t return ring(object(topology, {type: \"Polygon\", arcs: [ring$$]}).coordinates[0]) > 0; // TODO allow spherical?\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 // this exterior ring has the same winding order\n\t // as any exterior ring in the original polygons.\n\t if ((n = arcs.length) > 1) {\n\t var sgn = exterior(polygons[0][0]);\n\t for (var i = 0, t; i < n; ++i) {\n\t if (sgn === exterior(arcs[i])) {\n\t t = arcs[0], arcs[0] = arcs[i], arcs[i] = t;\n\t break;\n\t }\n\t }\n\t }\n\t\n\t return arcs;\n\t })\n\t };\n\t }\n\t\n\t function 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\t function compareArea(a, b) {\n\t return a[1][2] - b[1][2];\n\t }\n\t\n\t function 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\t function presimplify(topology, triangleArea) {\n\t var absolute$$ = absolute(topology.transform),\n\t relative$$ = relative(topology.transform),\n\t heap = minAreaHeap();\n\t\n\t if (!triangleArea) triangleArea = triangle;\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\t var version = \"1.6.24\";\n\t\n\t exports.version = version;\n\t exports.mesh = mesh;\n\t exports.meshArcs = meshArcs;\n\t exports.merge = merge;\n\t exports.mergeArcs = mergeArcs;\n\t exports.feature = feature;\n\t exports.neighbors = neighbors;\n\t exports.presimplify = presimplify;\n\t\n\t}));\n\n/***/ },\n/* 57 */\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 sum = 0,\n\t i, j, last;\n\t\n\t // calculate original winding order of a polygon ring\n\t for (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\n\t // link points into circular doubly-linked list in the specified winding order\n\t if (clockwise === (sum > 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 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 // a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])\n\t if (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 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 (hole.x === m.x) 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 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 >= m.x &&\n\t pointInTriangle(hy < m.y ? hx : qx, hy, m.x, m.y, hy < m.y ? 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 equals(a, b) || 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 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\n\n/***/ },\n/* 58 */\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__(3);\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/* 59 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar GreinerHormann = __webpack_require__(60);\n\tvar Edge = __webpack_require__(65);\n\tvar intersection = __webpack_require__(66);\n\t\n\t\"use strict\";\n\t\n\tvar min = Math.min,\n\t max = Math.max,\n\t atan2 = Math.atan2;\n\t\n\t/**\n\t * Offset builder\n\t *\n\t * @param {Array.<Object>=} vertices\n\t * @param {Number=} arcSegments\n\t * @constructor\n\t */\n\tfunction Offset(vertices, arcSegments) {\n\t\n\t /**\n\t * @type {Array.<Object>}\n\t */\n\t this.vertices = null;\n\t\n\t /**\n\t * @type {Array.<Edge>}\n\t */\n\t this.edges = null;\n\t\n\t /**\n\t * @type {Boolean}\n\t */\n\t this._closed = false;\n\t\n\t if (vertices) {\n\t this.data(vertices);\n\t }\n\t\n\t /**\n\t * Segments in edge bounding arches\n\t * @type {Number}\n\t */\n\t this._arcSegments = arcSegments || 5;\n\t};\n\t\n\t/**\n\t * Change data set\n\t * @param {Array.<Array>} vertices\n\t * @return {Offset}\n\t */\n\tOffset.prototype.data = function(vertices) {\n\t vertices = this.validate(vertices);\n\t\n\t var edges = [];\n\t for (var i = 0, len = vertices.length; i < len; i++) {\n\t edges.push(new Edge(vertices[i], vertices[(i + 1) % len]));\n\t }\n\t\n\t this.vertices = vertices;\n\t this.edges = edges;\n\t return this;\n\t};\n\t\n\t/**\n\t * @param {Number} arcSegments\n\t * @return {Offset}\n\t */\n\tOffset.prototype.arcSegments = function(arcSegments) {\n\t this._arcSegments = arcSegments;\n\t return this;\n\t};\n\t\n\t/**\n\t * Validates if the first and last points repeat\n\t * TODO: check CCW\n\t *\n\t * @param {Array.<Object>} vertices\n\t */\n\tOffset.prototype.validate = function(vertices) {\n\t var len = vertices.length;\n\t if (vertices[0][0] === vertices[len - 1][0] &&\n\t vertices[0][1] === vertices[len - 1][1]) {\n\t vertices = vertices.slice(0, len - 1);\n\t this._closed = true;\n\t }\n\t return vertices;\n\t};\n\t\n\t/**\n\t * Creates arch between two edges\n\t *\n\t * @param {Array.<Object>} vertices\n\t * @param {Object} center\n\t * @param {Number} radius\n\t * @param {Object} startVertex\n\t * @param {Object} endVertex\n\t * @param {Number} segments\n\t * @param {Boolean} outwards\n\t */\n\tOffset.prototype.createArc = function(vertices, center, radius, startVertex,\n\t endVertex, segments, outwards) {\n\t\n\t var PI2 = Math.PI * 2,\n\t startAngle = atan2(startVertex[1] - center[1], startVertex[0] - center[0]),\n\t endAngle = atan2(endVertex[1] - center[1], endVertex[0] - center[0]);\n\t\n\t // odd number please\n\t if (segments % 2 === 0) {\n\t segments -= 1;\n\t }\n\t\n\t if (startAngle < 0) {\n\t startAngle += PI2;\n\t }\n\t\n\t if (endAngle < 0) {\n\t endAngle += PI2;\n\t }\n\t\n\t var angle = ((startAngle > endAngle) ?\n\t (startAngle - endAngle) :\n\t (startAngle + PI2 - endAngle)),\n\t segmentAngle = ((outwards) ? -angle : PI2 - angle) / segments;\n\t\n\t vertices.push(startVertex);\n\t for (var i = 1; i < segments; ++i) {\n\t angle = startAngle + segmentAngle * i;\n\t vertices.push([\n\t center[0] + Math.cos(angle) * radius,\n\t center[1] + Math.sin(angle) * radius\n\t ]);\n\t }\n\t vertices.push(endVertex);\n\t};\n\t\n\t/**\n\t * Create padding polygon\n\t *\n\t * @param {Number} distance\n\t * @return {Array.<Number>}\n\t */\n\tOffset.prototype.padding = function(dist) {\n\t var offsetEdges = [],\n\t vertices = [],\n\t i, len, union;\n\t\n\t for (i = 0, len = this.edges.length; i < len; i++) {\n\t var edge = this.edges[i],\n\t dx = edge._outNormal[0] * dist,\n\t dy = edge._outNormal[1] * dist;\n\t offsetEdges.push(edge.offset(dx, dy));\n\t }\n\t\n\t for (i = 0, len = offsetEdges.length; i < len; i++) {\n\t var thisEdge = offsetEdges[i],\n\t prevEdge = offsetEdges[(i + len - 1) % len],\n\t vertex = intersection(\n\t prevEdge.current,\n\t prevEdge.next,\n\t thisEdge.current,\n\t thisEdge.next);\n\t\n\t if (vertex)\n\t vertices.push(vertex);\n\t else {\n\t this.createArc(\n\t vertices,\n\t this.edges[i].current,\n\t dist,\n\t prevEdge.next,\n\t thisEdge.current,\n\t this._arcSegments,\n\t false);\n\t }\n\t }\n\t union = GreinerHormann.union(vertices, vertices);\n\t vertices = union ? union[0] : vertices;\n\t\n\t vertices = this.ensureLastPoint(vertices);\n\t return vertices;\n\t};\n\t\n\t/**\n\t * Creates margin polygon\n\t * @param {Number} dist\n\t * @return {Array.<Object>}\n\t */\n\tOffset.prototype.margin = function(dist) {\n\t var offsetEdges = [],\n\t vertices = [],\n\t i, len, union;\n\t for (i = 0, len = this.edges.length; i < len; i++) {\n\t var edge = this.edges[i],\n\t dx = edge._inNormal[0] * dist,\n\t dy = edge._inNormal[1] * dist;\n\t\n\t offsetEdges.push(edge.offset(dx, dy));\n\t }\n\t\n\t for (i = 0, len = offsetEdges.length; i < len; i++) {\n\t var thisEdge = offsetEdges[i],\n\t prevEdge = offsetEdges[(i + len - 1) % len],\n\t vertex = intersection(\n\t prevEdge.current,\n\t prevEdge.next,\n\t thisEdge.current,\n\t thisEdge.next\n\t );\n\t\n\t if (vertex) {\n\t vertices.push(vertex);\n\t } else {\n\t this.createArc(\n\t vertices,\n\t this.edges[i].current,\n\t dist,\n\t prevEdge.next,\n\t thisEdge.current,\n\t this._arcSegments,\n\t true\n\t );\n\t }\n\t }\n\t\n\t union = GreinerHormann.union(vertices, vertices);\n\t if (union) {\n\t union = union[0];\n\t // that's the toll\n\t vertices = union.slice(0, union.length / 2);\n\t }\n\t\n\t vertices = this.ensureLastPoint(vertices);\n\t return vertices;\n\t};\n\t\n\t/**\n\t * @param {Array.<Object>} vertices\n\t * @return {Array.<Object>}\n\t */\n\tOffset.prototype.ensureLastPoint = function(vertices) {\n\t if (this._closed) {\n\t vertices.push([\n\t vertices[0][0],\n\t vertices[0][1]\n\t ]);\n\t }\n\t return vertices;\n\t};\n\t\n\t/**\n\t * Decides by the sign if it's a padding or a margin\n\t *\n\t * @param {Number} dist\n\t * @return {Array.<Object>}\n\t */\n\tOffset.prototype.offset = function(dist) {\n\t return dist === 0 ?\n\t this.vertices :\n\t (dist > 0 ? this.margin(dist) : this.padding(-dist));\n\t};\n\t\n\tmodule.exports = Offset;\n\n\n/***/ },\n/* 60 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar clip = __webpack_require__(61);\n\t\n\tmodule.exports = {\n\t /**\n\t * @api\n\t * @param {Array.<Array.<Number>|Array.<Object>} polygonA\n\t * @param {Array.<Array.<Number>|Array.<Object>} polygonB\n\t * @return {Array.<Array.<Number>>|Array.<Array.<Object>|Null}\n\t */\n\t union: function(polygonA, polygonB) {\n\t return clip(polygonA, polygonB, false, false);\n\t },\n\t\n\t /**\n\t * @api\n\t * @param {Array.<Array.<Number>|Array.<Object>} polygonA\n\t * @param {Array.<Array.<Number>|Array.<Object>} polygonB\n\t * @return {Array.<Array.<Number>>|Array.<Array.<Object>>|Null}\n\t */\n\t intersection: function(polygonA, polygonB) {\n\t return clip(polygonA, polygonB, true, true);\n\t },\n\t\n\t /**\n\t * @api\n\t * @param {Array.<Array.<Number>|Array.<Object>} polygonA\n\t * @param {Array.<Array.<Number>|Array.<Object>} polygonB\n\t * @return {Array.<Array.<Number>>|Array.<Array.<Object>>|Null}\n\t */\n\t diff: function(polygonA, polygonB) {\n\t return clip(polygonA, polygonB, false, true);\n\t },\n\t\n\t clip: clip\n\t};\n\n\n/***/ },\n/* 61 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Polygon = __webpack_require__(62);\n\t\n\t/**\n\t * Clip driver\n\t * @api\n\t * @param {Array.<Array.<Number>>} polygonA\n\t * @param {Array.<Array.<Number>>} polygonB\n\t * @param {Boolean} sourceForwards\n\t * @param {Boolean} clipForwards\n\t * @return {Array.<Array.<Number>>}\n\t */\n\tmodule.exports = function(polygonA, polygonB, eA, eB) {\n\t var result, source = new Polygon(polygonA),\n\t clip = new Polygon(polygonB),\n\t result = source.clip(clip, eA, eB);\n\t\n\t return result;\n\t};\n\n\n/***/ },\n/* 62 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Vertex = __webpack_require__(63);\n\tvar Intersection = __webpack_require__(64);\n\t\n\t/**\n\t * Polygon representation\n\t * @param {Array.<Array.<Number>>} p\n\t * @param {Boolean=} arrayVertices\n\t *\n\t * @constructor\n\t */\n\tvar Polygon = function(p, arrayVertices) {\n\t\n\t /**\n\t * @type {Vertex}\n\t */\n\t this.first = null;\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.vertices = 0;\n\t\n\t /**\n\t * @type {Vertex}\n\t */\n\t this._lastUnprocessed = null;\n\t\n\t /**\n\t * Whether to handle input and output as [x,y] or {x:x,y:y}\n\t * @type {Boolean}\n\t */\n\t this._arrayVertices = (typeof arrayVertices === \"undefined\") ?\n\t Array.isArray(p[0]) :\n\t arrayVertices;\n\t\n\t for (var i = 0, len = p.length; i < len; i++) {\n\t this.addVertex(new Vertex(p[i]));\n\t }\n\t};\n\t\n\t/**\n\t * Add a vertex object to the polygon\n\t * (vertex is added at the 'end' of the list')\n\t *\n\t * @param vertex\n\t */\n\tPolygon.prototype.addVertex = function(vertex) {\n\t if (this.first == null) {\n\t this.first = vertex;\n\t this.first.next = vertex;\n\t this.first.prev = vertex;\n\t } else {\n\t var next = this.first,\n\t prev = next.prev;\n\t\n\t next.prev = vertex;\n\t vertex.next = next;\n\t vertex.prev = prev;\n\t prev.next = vertex;\n\t }\n\t this.vertices++;\n\t};\n\t\n\t/**\n\t * Inserts a vertex inbetween start and end\n\t *\n\t * @param {Vertex} vertex\n\t * @param {Vertex} start\n\t * @param {Vertex} end\n\t */\n\tPolygon.prototype.insertVertex = function(vertex, start, end) {\n\t var prev, curr = start;\n\t\n\t while (!curr.equals(end) && curr._distance < vertex._distance) {\n\t curr = curr.next;\n\t }\n\t\n\t vertex.next = curr;\n\t prev = curr.prev;\n\t\n\t vertex.prev = prev;\n\t prev.next = vertex;\n\t curr.prev = vertex;\n\t\n\t this.vertices++;\n\t};\n\t\n\t/**\n\t * Get next non-intersection point\n\t * @param {Vertex} v\n\t * @return {Vertex}\n\t */\n\tPolygon.prototype.getNext = function(v) {\n\t var c = v;\n\t while (c._isIntersection) {\n\t c = c.next;\n\t }\n\t return c;\n\t};\n\t\n\t/**\n\t * Unvisited intersection\n\t * @return {Vertex}\n\t */\n\tPolygon.prototype.getFirstIntersect = function() {\n\t var v = this._firstIntersect || this.first;\n\t\n\t do {\n\t if (v._isIntersection && !v._visited) {\n\t break;\n\t }\n\t\n\t v = v.next;\n\t } while (!v.equals(this.first));\n\t\n\t this._firstIntersect = v;\n\t return v;\n\t};\n\t\n\t/**\n\t * Does the polygon have unvisited vertices\n\t * @return {Boolean} [description]\n\t */\n\tPolygon.prototype.hasUnprocessed = function() {\n\t var v = this._lastUnprocessed || this.first;\n\t do {\n\t if (v._isIntersection && !v._visited) {\n\t this._lastUnprocessed = v;\n\t return true;\n\t }\n\t\n\t v = v.next;\n\t } while (!v.equals(this.first));\n\t\n\t this._lastUnprocessed = null;\n\t return false;\n\t};\n\t\n\t/**\n\t * The output depends on what you put in, arrays or objects\n\t * @return {Array.<Array<Number>|Array.<Object>}\n\t */\n\tPolygon.prototype.getPoints = function() {\n\t var points = [],\n\t v = this.first;\n\t\n\t if (this._arrayVertices) {\n\t do {\n\t points.push([v.x, v.y]);\n\t v = v.next;\n\t } while (v !== this.first);\n\t } else {\n\t do {\n\t points.push({\n\t x: v.x,\n\t y: v.y\n\t });\n\t v = v.next;\n\t } while (v !== this.first);\n\t }\n\t\n\t return points;\n\t};\n\t\n\t/**\n\t * Clip polygon against another one.\n\t * Result depends on algorithm direction:\n\t *\n\t * Intersection: forwards forwards\n\t * Union: backwars backwards\n\t * Diff: backwards forwards\n\t *\n\t * @param {Polygon} clip\n\t * @param {Boolean} sourceForwards\n\t * @param {Boolean} clipForwards\n\t */\n\tPolygon.prototype.clip = function(clip, sourceForwards, clipForwards) {\n\t var sourceVertex = this.first,\n\t clipVertex = clip.first,\n\t sourceInClip, clipInSource;\n\t\n\t // calculate and mark intersections\n\t do {\n\t if (!sourceVertex._isIntersection) {\n\t do {\n\t if (!clipVertex._isIntersection) {\n\t var i = new Intersection(\n\t sourceVertex,\n\t this.getNext(sourceVertex.next),\n\t clipVertex, clip.getNext(clipVertex.next));\n\t\n\t if (i.valid()) {\n\t var sourceIntersection =\n\t Vertex.createIntersection(i.x, i.y, i.toSource),\n\t clipIntersection =\n\t Vertex.createIntersection(i.x, i.y, i.toClip);\n\t\n\t sourceIntersection._corresponding = clipIntersection;\n\t clipIntersection._corresponding = sourceIntersection;\n\t\n\t this.insertVertex(\n\t sourceIntersection,\n\t sourceVertex,\n\t this.getNext(sourceVertex.next));\n\t clip.insertVertex(\n\t clipIntersection,\n\t clipVertex,\n\t clip.getNext(clipVertex.next));\n\t }\n\t }\n\t clipVertex = clipVertex.next;\n\t } while (!clipVertex.equals(clip.first));\n\t }\n\t\n\t sourceVertex = sourceVertex.next;\n\t } while (!sourceVertex.equals(this.first));\n\t\n\t // phase two - identify entry/exit points\n\t sourceVertex = this.first;\n\t clipVertex = clip.first;\n\t\n\t sourceInClip = sourceVertex.isInside(clip);\n\t clipInSource = clipVertex.isInside(this);\n\t\n\t sourceForwards ^= sourceInClip;\n\t clipForwards ^= clipInSource;\n\t\n\t do {\n\t if (sourceVertex._isIntersection) {\n\t sourceVertex._isEntry = sourceForwards;\n\t sourceForwards = !sourceForwards;\n\t }\n\t sourceVertex = sourceVertex.next;\n\t } while (!sourceVertex.equals(this.first));\n\t\n\t do {\n\t if (clipVertex._isIntersection) {\n\t clipVertex._isEntry = clipForwards;\n\t clipForwards = !clipForwards;\n\t }\n\t clipVertex = clipVertex.next;\n\t } while (!clipVertex.equals(clip.first));\n\t\n\t // phase three - construct a list of clipped polygons\n\t var list = [];\n\t\n\t while (this.hasUnprocessed()) {\n\t var current = this.getFirstIntersect(),\n\t // keep format\n\t clipped = new Polygon([], this._arrayVertices);\n\t\n\t clipped.addVertex(new Vertex(current.x, current.y));\n\t do {\n\t current.visit();\n\t if (current._isEntry) {\n\t do {\n\t current = current.next;\n\t clipped.addVertex(new Vertex(current.x, current.y));\n\t } while (!current._isIntersection);\n\t\n\t } else {\n\t do {\n\t current = current.prev;\n\t clipped.addVertex(new Vertex(current.x, current.y));\n\t } while (!current._isIntersection);\n\t }\n\t current = current._corresponding;\n\t } while (!current._visited);\n\t\n\t list.push(clipped.getPoints());\n\t }\n\t\n\t if (list.length === 0) {\n\t if (sourceInClip) {\n\t list.push(this.getPoints());\n\t }\n\t if (clipInSource) {\n\t list.push(clip.getPoints());\n\t }\n\t if (list.length === 0) {\n\t list = null;\n\t }\n\t }\n\t\n\t return list;\n\t};\n\t\n\tmodule.exports = Polygon;\n\n\n/***/ },\n/* 63 */\n/***/ function(module, exports) {\n\n\t/**\n\t * Vertex representation\n\t *\n\t * @param {Number|Array.<Number>} x\n\t * @param {Number=} y\n\t *\n\t * @constructor\n\t */\n\tvar Vertex = function(x, y) {\n\t\n\t if (arguments.length === 1) {\n\t // Coords\n\t if (Array.isArray(x)) {\n\t y = x[1];\n\t x = x[0];\n\t } else {\n\t y = x.y;\n\t x = x.x;\n\t }\n\t }\n\t\n\t /**\n\t * X coordinate\n\t * @type {Number}\n\t */\n\t this.x = x;\n\t\n\t /**\n\t * Y coordinate\n\t * @type {Number}\n\t */\n\t this.y = y;\n\t\n\t /**\n\t * Next node\n\t * @type {Vertex}\n\t */\n\t this.next = null;\n\t\n\t /**\n\t * Previous vertex\n\t * @type {Vertex}\n\t */\n\t this.prev = null;\n\t\n\t /**\n\t * Corresponding intersection in other polygon\n\t */\n\t this._corresponding = null;\n\t\n\t /**\n\t * Distance from previous\n\t */\n\t this._distance = 0.0;\n\t\n\t /**\n\t * Entry/exit point in another polygon\n\t * @type {Boolean}\n\t */\n\t this._isEntry = true;\n\t\n\t /**\n\t * Intersection vertex flag\n\t * @type {Boolean}\n\t */\n\t this._isIntersection = false;\n\t\n\t /**\n\t * Loop check\n\t * @type {Boolean}\n\t */\n\t this._visited = false;\n\t};\n\t\n\t/**\n\t * Creates intersection vertex\n\t * @param {Number} x\n\t * @param {Number} y\n\t * @param {Number} distance\n\t * @return {Vertex}\n\t */\n\tVertex.createIntersection = function(x, y, distance) {\n\t var vertex = new Vertex(x, y);\n\t vertex._distance = distance;\n\t vertex._isIntersection = true;\n\t vertex._isEntry = false;\n\t return vertex;\n\t};\n\t\n\t/**\n\t * Mark as visited\n\t */\n\tVertex.prototype.visit = function() {\n\t this._visited = true;\n\t if (this._corresponding !== null && !this._corresponding._visited) {\n\t this._corresponding.visit();\n\t }\n\t};\n\t\n\t/**\n\t * Convenience\n\t * @param {Vertex} v\n\t * @return {Boolean}\n\t */\n\tVertex.prototype.equals = function(v) {\n\t return this.x === v.x && this.y === v.y;\n\t};\n\t\n\t/**\n\t * Check if vertex is inside a polygon by odd-even rule:\n\t * If the number of intersections of a ray out of the point and polygon\n\t * segments is odd - the point is inside.\n\t * @param {Polygon} poly\n\t * @return {Boolean}\n\t */\n\tVertex.prototype.isInside = function(poly) {\n\t var oddNodes = false,\n\t vertex = poly.first,\n\t next = vertex.next,\n\t x = this.x,\n\t y = this.y;\n\t\n\t do {\n\t if ((vertex.y < y && next.y >= y ||\n\t next.y < y && vertex.y >= y) &&\n\t (vertex.x <= x || next.x <= x)) {\n\t\n\t oddNodes ^= (vertex.x + (y - vertex.y) /\n\t (next.y - vertex.y) * (next.x - vertex.x) < x);\n\t }\n\t\n\t vertex = vertex.next;\n\t next = vertex.next || poly.first;\n\t } while (!vertex.equals(poly.first));\n\t\n\t return oddNodes;\n\t};\n\t\n\tmodule.exports = Vertex;\n\n\n/***/ },\n/* 64 */\n/***/ function(module, exports) {\n\n\t/**\n\t * Intersection\n\t * @param {Vertex} s1\n\t * @param {Vertex} s2\n\t * @param {Vertex} c1\n\t * @param {Vertex} c2\n\t * @constructor\n\t */\n\tvar Intersection = function(s1, s2, c1, c2) {\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.x = 0.0;\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.y = 0.0;\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.toSource = 0.0;\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.toClip = 0.0;\n\t\n\t var d = (c2.y - c1.y) * (s2.x - s1.x) - (c2.x - c1.x) * (s2.y - s1.y);\n\t\n\t if (d === 0) {\n\t return;\n\t }\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.toSource = ((c2.x - c1.x) * (s1.y - c1.y) - (c2.y - c1.y) * (s1.x - c1.x)) / d;\n\t\n\t /**\n\t * @type {Number}\n\t */\n\t this.toClip = ((s2.x - s1.x) * (s1.y - c1.y) - (s2.y - s1.y) * (s1.x - c1.x)) / d;\n\t\n\t if (this.valid()) {\n\t this.x = s1.x + this.toSource * (s2.x - s1.x);\n\t this.y = s1.y + this.toSource * (s2.y - s1.y);\n\t }\n\t};\n\t\n\t/**\n\t * @return {Boolean}\n\t */\n\tIntersection.prototype.valid = function() {\n\t return (0 < this.toSource && this.toSource < 1) && (0 < this.toClip && this.toClip < 1);\n\t};\n\t\n\tmodule.exports = Intersection;\n\n\n/***/ },\n/* 65 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\t/**\n\t * Offset edge of the polygon\n\t *\n\t * @param {Object} current\n\t * @param {Object} next\n\t * @cosntructor\n\t */\n\tfunction Edge(current, next) {\n\t\n\t /**\n\t * @type {Object}\n\t */\n\t this.current = current;\n\t\n\t /**\n\t * @type {Object}\n\t */\n\t this.next = next;\n\t\n\t /**\n\t * @type {Object}\n\t */\n\t this._inNormal = this.inwardsNormal();\n\t\n\t /**\n\t * @type {Object}\n\t */\n\t this._outNormal = this.outwardsNormal();\n\t};\n\t\n\t/**\n\t * Creates outwards normal\n\t * @return {Object}\n\t */\n\tEdge.prototype.outwardsNormal = function() {\n\t var inwards = this.inwardsNormal();\n\t return [\n\t -inwards[0],\n\t -inwards[1]\n\t ];\n\t};\n\t\n\t/**\n\t * Creates inwards normal\n\t * @return {Object}\n\t */\n\tEdge.prototype.inwardsNormal = function() {\n\t var dx = this.next[0] - this.current[0],\n\t dy = this.next[1] - this.current[1],\n\t edgeLength = Math.sqrt(dx * dx + dy * dy);\n\t\n\t return [\n\t -dy / edgeLength,\n\t dx / edgeLength\n\t ];\n\t};\n\t\n\t/**\n\t * Offsets the edge by dx, dy\n\t * @param {Number} dx\n\t * @param {Number} dy\n\t * @return {Edge}\n\t */\n\tEdge.prototype.offset = function(dx, dy) {\n\t var current = this.current,\n\t next = this.next;\n\t\n\t return new Edge([\n\t current[0] + dx,\n\t current[1] + dy\n\t ], [\n\t next[0] + dx,\n\t next[1] + dy\n\t ]);\n\t};\n\t\n\tmodule.exports = Edge;\n\n\n/***/ },\n/* 66 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\t/**\n\t * Vector intersection, if present\n\t *\n\t * @param {Object} A0\n\t * @param {Object} A1\n\t * @param {Object} B0\n\t * @param {Object} B1\n\t *\n\t * @return {Object|null}\n\t */\n\tmodule.exports = function intersection(A0, A1, B0, B1) {\n\t var den = (B1[1] - B0[1]) * (A1[0] - A0[0]) -\n\t (B1[0] - B0[0]) * (A1[1] - A0[1]);\n\t\n\t // lines are parallel or conincident\n\t if (den == 0) {\n\t return null;\n\t }\n\t\n\t var ua = ((B1[0] - B0[0]) * (A0[1] - B0[1]) -\n\t (B1[1] - B0[1]) * (A0[0] - B0[0])) / den;\n\t\n\t var ub = ((A1[0] - A0[0]) * (A0[1] - B0[1]) -\n\t (A1[1] - A0[1]) * (A0[0] - B0[0])) / den;\n\t\n\t if (ua < 0 || ub < 0 || ua > 1 || ub > 1) {\n\t return null;\n\t }\n\t\n\t return [\n\t A0[0] + ua * (A1[0] - A0[0]),\n\t A0[1] + ua * (A1[1] - A0[1])\n\t ];\n\t};\n\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 bd85d32bfc37ee7d2eb7\n **/","import World from './World';\nimport Controls from './controls/index';\nimport EnvironmentLayer from './layer/environment/EnvironmentLayer';\nimport ImageTileLayer from './layer/tile/ImageTileLayer';\nimport TopoJSONTileLayer from './layer/tile/TopoJSONTileLayer';\nimport Point from './geo/Point';\nimport LatLon from './geo/LatLon';\n\nconst VIZI = {\n version: '0.3',\n\n // Public API\n World: World,\n Controls: Controls,\n EnvironmentLayer: EnvironmentLayer,\n ImageTileLayer: ImageTileLayer,\n TopoJSONTileLayer: TopoJSONTileLayer,\n Point: Point,\n LatLon: LatLon\n};\n\nexport default VIZI;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/vizicities.js\n **/","import EventEmitter from 'eventemitter3';\nimport extend from 'lodash.assign';\nimport CRS from './geo/CRS/index';\nimport Point from './geo/Point';\nimport LatLon from './geo/LatLon';\nimport Engine from './engine/Engine';\n\n// Pretty much any event someone using ViziCities would need will be emitted or\n// proxied by World (eg. render events, etc)\n\nclass World extends EventEmitter {\n constructor(domId, options) {\n super();\n\n var defaults = {\n crs: CRS.EPSG3857,\n skybox: false\n };\n\n this.options = extend(defaults, options);\n\n this._layers = [];\n this._controls = [];\n\n this._initContainer(domId);\n this._initEngine();\n this._initEnvironment();\n this._initEvents();\n\n // Kick off the update and render loop\n this._update();\n }\n\n _initContainer(domId) {\n this._container = document.getElementById(domId);\n }\n\n _initEngine() {\n this._engine = Engine(this._container);\n\n // Engine events\n //\n // Consider proxying these through events on World for public access\n // this._engine.on('preRender', () => {});\n // this._engine.on('postRender', () => {});\n }\n\n _initEnvironment() {\n // Not sure if I want to keep this as a private API\n //\n // Makes sense to allow others to customise their environment so perhaps\n // add some method of disable / overriding the environment settings\n this._environment = VIZI.EnvironmentLayer({\n skybox: this.options.skybox\n }).addTo(this);\n }\n\n _initEvents() {\n this.on('controlsMoveEnd', this._onControlsMoveEnd);\n }\n\n _onControlsMoveEnd(point) {\n var _point = Point(point.x, point.z);\n this._resetView(this.pointToLatLon(_point), _point);\n }\n\n // Reset world view\n _resetView(latlon, point) {\n this.emit('preResetView');\n\n this._moveStart();\n this._move(latlon, point);\n this._moveEnd();\n\n this.emit('postResetView');\n }\n\n _moveStart() {\n this.emit('moveStart');\n }\n\n _move(latlon, point) {\n this._lastPosition = latlon;\n this.emit('move', latlon, point);\n }\n _moveEnd() {\n this.emit('moveEnd');\n }\n\n _update() {\n var delta = this._engine.clock.getDelta();\n\n // Once _update is called it will run forever, for now\n window.requestAnimationFrame(this._update.bind(this));\n\n // Update controls\n this._controls.forEach(controls => {\n controls.update();\n });\n\n this.emit('preUpdate', delta);\n this._engine.update(delta);\n this.emit('postUpdate', delta);\n }\n\n // Set world view\n setView(latlon) {\n // Store initial geographic coordinate for the [0,0,0] world position\n //\n // The origin point doesn't move in three.js / 3D space so only set it once\n // here instead of every time _resetView is called\n //\n // If it was updated every time then coorindates would shift over time and\n // would be out of place / context with previously-placed points (0,0 would\n // refer to a different point each time)\n this._originLatlon = latlon;\n this._originPoint = this.project(latlon);\n\n this._resetView(latlon);\n return this;\n }\n\n // Return world geographic position\n getPosition() {\n return this._lastPosition;\n }\n\n // Transform geographic coordinate to world point\n //\n // This doesn't take into account the origin offset\n //\n // For example, this takes a geographic coordinate and returns a point\n // relative to the origin point of the projection (not the world)\n project(latlon) {\n return this.options.crs.latLonToPoint(LatLon(latlon));\n }\n\n // Transform world point to geographic coordinate\n //\n // This doesn't take into account the origin offset\n //\n // For example, this takes a point relative to the origin point of the\n // projection (not the world) and returns a geographic coordinate\n unproject(point) {\n return this.options.crs.pointToLatLon(Point(point));\n }\n\n // Takes into account the origin offset\n //\n // For example, this takes a geographic coordinate and returns a point\n // relative to the three.js / 3D origin (0,0)\n latLonToPoint(latlon) {\n var projectedPoint = this.project(LatLon(latlon));\n return projectedPoint._subtract(this._originPoint);\n }\n\n // Takes into account the origin offset\n //\n // For example, this takes a point relative to the three.js / 3D origin (0,0)\n // and returns the exact geographic coordinate at that point\n pointToLatLon(point) {\n var projectedPoint = Point(point).add(this._originPoint);\n return this.unproject(projectedPoint);\n }\n\n // Return pointscale for a given geographic coordinate\n pointScale(latlon, accurate) {\n return this.options.crs.pointScale(latlon, accurate);\n }\n\n // Convert from real meters to world units\n //\n // TODO: Would be nice not to have to pass in a pointscale here\n metresToWorld(metres, pointScale, zoom) {\n return this.options.crs.metresToWorld(metres, pointScale, zoom);\n }\n\n // Convert from real meters to world units\n //\n // TODO: Would be nice not to have to pass in a pointscale here\n worldToMetres(worldUnits, pointScale, zoom) {\n return this.options.crs.worldToMetres(worldUnits, pointScale, zoom);\n }\n\n // Unsure if it's a good idea to expose this here for components like\n // GridLayer to use (eg. to keep track of a frustum)\n getCamera() {\n return this._engine._camera;\n }\n\n addLayer(layer) {\n layer._addToWorld(this);\n\n this._layers.push(layer);\n\n // Could move this into Layer but it'll do here for now\n this._engine._scene.add(layer._layer);\n\n this.emit('layerAdded', layer);\n return this;\n }\n\n // Remove layer and perform clean up operations\n removeLayer(layer) {\n var layerIndex = this._layers.indexOf(layer);\n\n if (layerIndex > -1) {\n // Remove from this._layers\n this._layers.splice(layerIndex, 1);\n };\n\n this._engine._scene.remove(layer._layer);\n\n layer.destroy();\n\n this.emit('layerRemoved');\n return this;\n }\n\n addControls(controls) {\n controls._addToWorld(this);\n\n this._controls.push(controls);\n\n this.emit('controlsAdded', controls);\n return this;\n }\n\n removeControls(controls) {}\n}\n\n// Initialise without requiring new keyword\nexport default function(domId, options) {\n return new World(domId, options);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/World.js\n **/","'use strict';\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 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 * Holds the assigned EventEmitters by name.\n *\n * @type {Object}\n * @private\n */\nEventEmitter.prototype._events = undefined;\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 {Functon} fn Callback function.\n * @param {Mixed} context 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 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 = 2\n ** module chunks = 0\n **/","/**\n * lodash 4.0.2 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\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/**\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 value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n length = length == null ? MAX_SAFE_INTEGER : length;\n return value > -1 && value % 1 == 0 && value < length;\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 [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\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 ((!eq(objValue, value) ||\n (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) ||\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 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 names to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object) {\n return copyObjectWith(source, props, object);\n}\n\n/**\n * This function is like `copyObject` except that it accepts a function to\n * customize copied values.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property names 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 copyObjectWith(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 newValue = customizer ? customizer(object[key], source[key], key, object, source) : 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 = typeof customizer == 'function' ? (length--, customizer) : undefined;\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 [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n * that affects 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 the provided 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, 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 return eq(object[index], value);\n }\n return false;\n}\n\n/**\n * Performs a [`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 * @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 * @type Function\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 &&\n !(typeof value == 'function' && isFunction(value)) && isLength(getLength(value));\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n // 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 [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, 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' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\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 properties of source objects to the destination\n * object. Source objects are applied from left to right. Subsequent sources\n * 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 * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\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 copyObject(source, keys(source), object);\n});\n\nmodule.exports = assign;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lodash.assign/index.js\n ** module id = 3\n ** module chunks = 0\n **/","/**\n * lodash 4.0.2 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\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/**\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 value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n length = length == null ? MAX_SAFE_INTEGER : length;\n return value > -1 && value % 1 == 0 && value < length;\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 [`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 getPrototypeOf = Object.getPrototypeOf,\n propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar 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 && getPrototypeOf(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 * @type Function\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 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 [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n * that affects 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 * 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 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 * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 * @type Function\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 * @type Function\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 &&\n !(typeof value == 'function' && isFunction(value)) && isLength(getLength(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 * @type Function\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object, 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 * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n // 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 [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, 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' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\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 * @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 * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 * @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 = 4\n ** module chunks = 0\n **/","/**\n * lodash 4.0.1 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\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\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 {...*} 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 [`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 an array.\n *\n * **Note:** This method is based on the [rest parameter](https://mdn.io/rest_parameters).\n *\n * @static\n * @memberOf _\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 * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n // 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 [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\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 * Converts `value` to an integer.\n *\n * **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3');\n * // => 3\n */\nfunction toInteger(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 var remainder = value % 1;\n return value === value ? (remainder ? value - remainder : value) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3);\n * // => 3\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3');\n * // => 3\n */\nfunction toNumber(value) {\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 = 5\n ** module chunks = 0\n **/","import EPSG3857 from './CRS.EPSG3857';\nimport {EPSG900913} from './CRS.EPSG3857';\nimport EPSG3395 from './CRS.EPSG3395';\nimport EPSG4326 from './CRS.EPSG4326';\nimport Simple from './CRS.Simple';\nimport Proj4 from './CRS.Proj4';\n\nconst CRS = {};\n\nCRS.EPSG3857 = EPSG3857;\nCRS.EPSG900913 = EPSG900913;\nCRS.EPSG3395 = EPSG3395;\nCRS.EPSG4326 = EPSG4326;\nCRS.Simple = Simple;\nCRS.Proj4 = Proj4;\n\nexport default CRS;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/index.js\n **/","/*\n * CRS.EPSG3857 (WGS 84 / Pseudo-Mercator) CRS implementation.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.EPSG3857.js\n */\n\nimport extend from 'lodash.assign';\nimport Earth from './CRS.Earth';\nimport SphericalMercator from '../projection/Projection.SphericalMercator';\nimport Transformation from '../../util/Transformation';\n\nvar _EPSG3857 = {\n code: 'EPSG:3857',\n projection: SphericalMercator,\n\n // Work out how to de-dupe this (scoping issue)\n transformScale: 1 / (Math.PI * SphericalMercator.R),\n\n // Scale and transformation inputs changed to account for central origin in\n // WebGL, instead of top-left origin used in Leaflet\n transformation: (function() {\n // TODO: Cannot use this.transformScale due to scope\n var scale = 1 / (Math.PI * SphericalMercator.R);\n\n return new Transformation(scale, 0, -scale, 0);\n }())\n};\n\nconst EPSG3857 = extend({}, Earth, _EPSG3857);\n\nconst EPSG900913 = extend({}, EPSG3857, {\n code: 'EPSG:900913'\n});\n\nexport {EPSG900913};\n\nexport default EPSG3857;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.EPSG3857.js\n **/","/*\n * CRS.Earth is the base class for all CRS representing Earth.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.Earth.js\n */\n\nimport extend from 'lodash.assign';\nimport CRS from './CRS';\nimport LatLon from '../LatLon';\n\nconst Earth = {\n wrapLon: [-180, 180],\n\n R: 6378137,\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\n 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 this.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 this.R * c;\n }\n },\n\n // Scale factor for converting between real metres and projected metres\n //\n // projectedMetres = realMetres * pointScale\n // realMetres = projectedMetres / pointScale\n //\n // Defaults to a scale factor of 1 if no calculation method exists\n //\n // Probably need to run this through the CRS transformation or similar so the\n // resulting scale is relative to the dimensions of the world space\n // Eg. 1 metre in projected space is likly scaled up or down to some other\n // number\n pointScale: function(latlon, accurate) {\n return (this.projection.pointScale) ? this.projection.pointScale(latlon, accurate) : [1, 1];\n },\n\n // Convert real metres to projected units\n //\n // Latitude scale is chosen because it fluctuates more than longitude\n 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\n projectedToMetres: function(projectedUnits, pointScale) {\n return projectedUnits / pointScale[1];\n },\n\n // Convert real metres to a value in world (WebGL) units\n metresToWorld: function(metres, pointScale, zoom) {\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 = this.metresToProjected(metres, pointScale);\n\n var scale = this.scale(zoom);\n\n // Half scale if using zoom as WebGL origin is in the centre, not top left\n if (zoom) {\n scale /= 2;\n }\n\n // Scale projected metres\n var scaledMetres = (scale * (this.transformScale * projectedMetres));\n\n // Not entirely sure why this is neccessary\n if (zoom) {\n scaledMetres /= pointScale[1];\n }\n\n return scaledMetres;\n },\n\n // Convert world (WebGL) units to a value in real metres\n worldToMetres: function(worldUnits, pointScale, zoom) {\n var scale = this.scale(zoom);\n\n // Half scale if using zoom as WebGL origin is in the centre, not top left\n if (zoom) {\n scale /= 2;\n }\n\n var projectedUnits = ((worldUnits / scale) / this.transformScale);\n var realMetres = this.projectedToMetres(projectedUnits, pointScale);\n\n // Not entirely sure why this is neccessary\n if (zoom) {\n realMetres *= pointScale[1];\n }\n\n return realMetres;\n }\n};\n\nexport default extend({}, CRS, Earth);\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.Earth.js\n **/","/*\n * CRS is the base object for all defined CRS (Coordinate Reference Systems)\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.js\n */\n\nimport LatLon from '../LatLon';\nimport Point from '../Point';\nimport wrapNum from '../../util/wrapNum';\n\nconst CRS = {\n // Scale factor determines final dimensions of world space\n //\n // Projection transformation in range -1 to 1 is multiplied by scale factor to\n // find final world coordinates\n //\n // Scale factor can be considered as half the amount of the desired dimension\n // for the largest side when transformation is equal to 1 or -1, or as the\n // distance between 0 and 1 on the largest side\n //\n // For example, if you want the world dimensions to be between -1000 and 1000\n // then the scale factor will be 1000\n scaleFactor: 1000000,\n\n // Converts geo coords to pixel / WebGL ones\n latLonToPoint: function(latlon, zoom) {\n var projectedPoint = this.projection.project(latlon);\n var scale = this.scale(zoom);\n\n // Half scale if using zoom as WebGL origin is in the centre, not top left\n if (zoom) {\n scale /= 2;\n }\n\n return this.transformation._transform(projectedPoint, scale);\n },\n\n // Converts pixel / WebGL coords to geo coords\n pointToLatLon: function(point, zoom) {\n var scale = this.scale(zoom);\n\n // Half scale if using zoom as WebGL origin is in the centre, not top left\n if (zoom) {\n scale /= 2;\n }\n\n var untransformedPoint = this.transformation.untransform(point, scale);\n\n return this.projection.unproject(untransformedPoint);\n },\n\n // Converts geo coords to projection-specific coords (e.g. in meters)\n project: function(latlon) {\n return this.projection.project(latlon);\n },\n\n // Converts projected coords to geo coords\n unproject: function(point) {\n return this.projection.unproject(point);\n },\n\n // If zoom is provided, returns the map width in pixels for a given zoom\n // Else, provides fixed scale value\n 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 this.scaleFactor;\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\n zoom: function(scale) {\n return Math.log(scale / 256) / Math.LN2;\n },\n\n // Returns the bounds of the world in projected coords if applicable\n getProjectedBounds: function(zoom) {\n if (this.infinite) { return null; }\n\n var b = this.projection.bounds;\n var s = this.scale(zoom);\n\n // Half scale if using zoom as WebGL origin is in the centre, not top left\n if (zoom) {\n s /= 2;\n }\n\n // Bottom left\n var min = this.transformation.transform(Point(b[0]), s);\n\n // Top right\n var max = this.transformation.transform(Point(b[1]), s);\n\n return [min, max];\n },\n\n // Whether a coordinate axis wraps in a given range (e.g. longitude from -180 to 180); depends on CRS\n // wrapLon: [min, max],\n // wrapLat: [min, max],\n\n // If true, the coordinate space will be unbounded (infinite in all directions)\n // infinite: false,\n\n // Wraps geo coords in certain ranges if applicable\n wrapLatLon: function(latlon) {\n var lat = this.wrapLat ? wrapNum(latlon.lat, this.wrapLat, true) : latlon.lat;\n var lon = this.wrapLon ? wrapNum(latlon.lon, this.wrapLon, true) : latlon.lon;\n var alt = latlon.alt;\n\n return LatLon(lat, lon, alt);\n }\n};\n\nexport default CRS;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.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\n// Initialise without requiring new keyword\n//\n// Accepts (LatLon), ([lat, lon, alt]), ([lat, lon]) and (lat, lon, alt)\n// Also converts between lng and lon\nexport default 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\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\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 default _point;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/Point.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 **/","/*\n * Spherical Mercator is the most popular map projection, used by EPSG:3857 CRS\n * used by default.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/projection/Projection.SphericalMercator.js\n */\n\nimport LatLon from '../LatLon';\nimport Point from '../Point';\n\nconst SphericalMercator = {\n // Radius / WGS84 semi-major axis\n R: 6378137,\n MAX_LATITUDE: 85.0511287798,\n\n // WGS84 eccentricity\n ECC: 0.081819191,\n ECC2: 0.081819191 * 0.081819191,\n\n project: function(latlon) {\n var d = Math.PI / 180;\n var max = this.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 this.R * latlon.lon * d,\n this.R * Math.log((1 + sin) / (1 - sin)) / 2\n );\n },\n\n unproject: function(point) {\n var d = 180 / Math.PI;\n\n return LatLon(\n (2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,\n point.x * d / this.R\n );\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/\n 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 = this.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 - this.ECC2) / Math.pow(1 - this.ECC2 * sinLat2, 3 / 2);\n\n // Radius prime meridian\n var v = a / Math.sqrt(1 - this.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 // Not using this.R due to scoping\n bounds: (function() {\n var d = 6378137 * Math.PI;\n return [[-d, -d], [d, d]];\n })()\n};\n\nexport default SphericalMercator;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/projection/Projection.SphericalMercator.js\n **/","/*\n * Transformation is an utility class to perform simple point transformations\n * through a 2d-matrix.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geometry/Transformation.js\n */\n\nimport Point from '../geo/Point';\n\nclass Transformation {\n constructor(a, b, c, d) {\n this._a = a;\n this._b = b;\n this._c = c;\n this._d = d;\n }\n\n transform(point, scale) {\n // Copy input point as to not destroy the original data\n return this._transform(point.clone(), scale);\n }\n\n // Destructive transform (faster)\n _transform(point, scale) {\n scale = scale || 1;\n\n point.x = scale * (this._a * point.x + this._b);\n point.y = scale * (this._c * point.y + this._d);\n return point;\n }\n\n untransform(point, scale) {\n scale = scale || 1;\n return Point(\n (point.x / scale - this._b) / this._a,\n (point.y / scale - this._d) / this._c\n );\n }\n}\n\nexport default Transformation;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/util/Transformation.js\n **/","/*\n * CRS.EPSG3395 (WGS 84 / World Mercator) CRS implementation.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.EPSG3395.js\n */\n\nimport extend from 'lodash.assign';\nimport Earth from './CRS.Earth';\nimport Mercator from '../projection/Projection.Mercator';\nimport Transformation from '../../util/Transformation';\n\nvar _EPSG3395 = {\n code: 'EPSG:3395',\n projection: Mercator,\n\n // Work out how to de-dupe this (scoping issue)\n transformScale: 1 / (Math.PI * Mercator.R),\n\n // Scale and transformation inputs changed to account for central origin in\n // WebGL, instead of top-left origin used in Leaflet\n transformation: (function() {\n // TODO: Cannot use this.transformScale due to scope\n var scale = 1 / (Math.PI * Mercator.R);\n\n return new Transformation(scale, 0, -scale, 0);\n }())\n};\n\nconst EPSG3395 = extend({}, Earth, _EPSG3395);\n\nexport default EPSG3395;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.EPSG3395.js\n **/","/*\n * Mercator projection that takes into account that the Earth is not a perfect\n * sphere. Less popular than spherical mercator; used by projections like\n * EPSG:3395.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/projection/Projection.Mercator.js\n */\n\nimport LatLon from '../LatLon';\nimport Point from '../Point';\n\nconst Mercator = {\n // Radius / WGS84 semi-major axis\n R: 6378137,\n R_MINOR: 6356752.314245179,\n\n // WGS84 eccentricity\n ECC: 0.081819191,\n ECC2: 0.081819191 * 0.081819191,\n\n project: function(latlon) {\n var d = Math.PI / 180;\n var r = this.R;\n var y = latlon.lat * d;\n var tmp = this.R_MINOR / r;\n var e = Math.sqrt(1 - tmp * tmp);\n var con = e * Math.sin(y);\n\n var ts = Math.tan(Math.PI / 4 - y / 2) / Math.pow((1 - con) / (1 + con), e / 2);\n y = -r * Math.log(Math.max(ts, 1E-10));\n\n return Point(latlon.lon * d * r, y);\n },\n\n unproject: function(point) {\n var d = 180 / Math.PI;\n var r = this.R;\n var tmp = this.R_MINOR / r;\n var e = Math.sqrt(1 - tmp * tmp);\n var ts = Math.exp(-point.y / r);\n var phi = Math.PI / 2 - 2 * Math.atan(ts);\n\n for (var i = 0, dphi = 0.1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {\n con = e * Math.sin(phi);\n con = Math.pow((1 - con) / (1 + con), e / 2);\n dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;\n phi += dphi;\n }\n\n return LatLon(phi * d, point.x * d / r);\n },\n\n // Scale factor for converting between real metres and projected metres\n //\n // projectedMetres = realMetres * pointScale\n // realMetres = projectedMetres / pointScale\n //\n // See pg.8: http://www.hydrometronics.com/downloads/Web%20Mercator%20-%20Non-Conformal,%20Non-Mercator%20(notes).pdf\n pointScale: function(latlon) {\n var rad = Math.PI / 180;\n var lat = latlon.lat * rad;\n var sinLat = Math.sin(lat);\n var sinLat2 = sinLat * sinLat;\n var cosLat = Math.cos(lat);\n\n var k = Math.sqrt(1 - this.ECC2 * sinLat2) / cosLat;\n\n // [scaleX, scaleY]\n return [k, k];\n },\n\n bounds: [[-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]]\n};\n\nexport default Mercator;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/projection/Projection.Mercator.js\n **/","/*\n * CRS.EPSG4326 is a CRS popular among advanced GIS specialists.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.EPSG4326.js\n */\n\nimport extend from 'lodash.assign';\nimport Earth from './CRS.Earth';\nimport LatLonProjection from '../projection/Projection.LatLon';\nimport Transformation from '../../util/Transformation';\n\nvar _EPSG4326 = {\n code: 'EPSG:4326',\n projection: LatLonProjection,\n\n // Work out how to de-dupe this (scoping issue)\n transformScale: 1 / 180,\n\n // Scale and transformation inputs changed to account for central origin in\n // WebGL, instead of top-left origin used in Leaflet\n //\n // TODO: Cannot use this.transformScale due to scope\n transformation: new Transformation(1 / 180, 0, -1 / 180, 0)\n};\n\nconst EPSG4326 = extend({}, Earth, _EPSG4326);\n\nexport default EPSG4326;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.EPSG4326.js\n **/","/*\n * Simple equirectangular (Plate Carree) projection, used by CRS like EPSG:4326\n * and Simple.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/projection/Projection.LonLat.js\n */\n\nimport LatLon from '../LatLon';\nimport Point from '../Point';\n\nconst ProjectionLatLon = {\n project: function(latlon) {\n return Point(latlon.lon, latlon.lat);\n },\n\n unproject: function(point) {\n return LatLon(point.y, point.x);\n },\n\n // Scale factor for converting between real metres and degrees\n //\n // degrees = realMetres * pointScale\n // realMetres = degrees / pointScale\n //\n // See: http://stackoverflow.com/questions/639695/how-to-convert-latitude-or-longitude-to-meters\n // See: http://gis.stackexchange.com/questions/75528/length-of-a-degree-where-do-the-terms-in-this-formula-come-from\n pointScale: function(latlon) {\n var m1 = 111132.92;\n var m2 = -559.82;\n var m3 = 1.175;\n var m4 = -0.0023;\n var p1 = 111412.84;\n var p2 = -93.5;\n var p3 = 0.118;\n\n var rad = Math.PI / 180;\n var lat = latlon.lat * rad;\n\n var latlen = m1 + m2 * Math.cos(2 * lat) + m3 * Math.cos(4 * lat) + m4 * Math.cos(6 * lat);\n var lonlen = p1 * Math.cos(lat) + p2 * Math.cos(3 * lat) + p3 * Math.cos(5 * lat);\n\n return [1 / latlen, 1 / lonlen];\n },\n\n bounds: [[-180, -90], [180, 90]]\n};\n\nexport default ProjectionLatLon;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/projection/Projection.LatLon.js\n **/","/*\n * A simple CRS that can be used for flat non-Earth maps like panoramas or game\n * maps.\n *\n * Based on:\n * https://github.com/Leaflet/Leaflet/blob/master/src/geo/crs/CRS.Simple.js\n */\n\nimport extend from 'lodash.assign';\nimport CRS from './CRS';\nimport LatLonProjection from '../projection/Projection.LatLon';\nimport Transformation from '../../util/Transformation';\n\nvar _Simple = {\n projection: LatLonProjection,\n\n // Straight 1:1 mapping (-1, -1 would be top-left)\n transformation: new Transformation(1, 0, 1, 0),\n\n scale: function(zoom) {\n // If zoom is provided then return scale based on map tile zoom\n if (zoom) {\n return Math.pow(2, zoom);\n // Else, make no change to scale – may need to increase this or make it a\n // user-definable variable\n } else {\n return 1;\n }\n },\n\n zoom: function(scale) {\n return Math.log(scale) / Math.LN2;\n },\n\n distance: function(latlon1, latlon2) {\n var dx = latlon2.lon - latlon1.lon;\n var dy = latlon2.lat - latlon1.lat;\n\n return Math.sqrt(dx * dx + dy * dy);\n },\n\n infinite: true\n};\n\nconst Simple = extend({}, CRS, _Simple);\n\nexport default Simple;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.Simple.js\n **/","/*\n * CRS.Proj4 for any Proj4-supported CRS.\n */\n\nimport extend from 'lodash.assign';\nimport Earth from './CRS.Earth';\nimport Proj4Projection from '../projection/Projection.Proj4';\nimport Transformation from '../../util/Transformation';\n\nvar _Proj4 = function(code, def, bounds) {\n var projection = Proj4Projection(def, bounds);\n\n // Transformation calcuations\n var diffX = projection.bounds[1][0] - projection.bounds[0][0];\n var diffY = projection.bounds[1][1] - projection.bounds[0][1];\n\n var halfX = diffX / 2;\n var halfY = diffY / 2;\n\n // This is the raw scale factor\n var scaleX = 1 / halfX;\n var scaleY = 1 / halfY;\n\n // Find the minimum scale factor\n //\n // The minimum scale factor comes from the largest side and is the one\n // you want to use for both axis so they stay relative in dimension\n var scale = Math.min(scaleX, scaleY);\n\n // Find amount to offset each axis by to make the central point lie on\n // the [0,0] origin\n var offsetX = scale * (projection.bounds[0][0] + halfX);\n var offsetY = scale * (projection.bounds[0][1] + halfY);\n\n return {\n code: code,\n projection: projection,\n\n transformScale: scale,\n\n // Map the input to a [-1,1] range with [0,0] in the centre\n transformation: new Transformation(scale, -offsetX, -scale, offsetY)\n };\n};\n\nconst Proj4 = function(code, def, bounds) {\n return extend({}, Earth, _Proj4(code, def, bounds));\n};\n\nexport default Proj4;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/CRS/CRS.Proj4.js\n **/","/*\n * Proj4 support for any projection.\n */\n\nimport proj4 from 'proj4';\nimport LatLon from '../LatLon';\nimport Point from '../Point';\n\nconst Proj4 = function(def, bounds) {\n var proj = proj4(def);\n\n var project = function(latlon) {\n return Point(proj.forward([latlon.lon, latlon.lat]));\n };\n\n var unproject = function(point) {\n var inverse = proj.inverse([point.x, point.y]);\n return LatLon(inverse[1], inverse[0]);\n };\n\n return {\n project: project,\n unproject: unproject,\n\n // Scale factor for converting between real metres and projected metres\\\n //\n // Need to work out the best way to provide the pointScale calculations\n // for custom, unknown projections (if wanting to override default)\n //\n // For now, user can manually override crs.pointScale or\n // crs.projection.pointScale\n //\n // projectedMetres = realMetres * pointScale\n // realMetres = projectedMetres / pointScale\n pointScale: function(latlon, accurate) {\n return [1, 1];\n },\n\n // Try and calculate bounds if none are provided\n //\n // This will provide incorrect bounds for some projections, so perhaps make\n // bounds a required input instead\n bounds: (function() {\n if (bounds) {\n return bounds;\n } else {\n var bottomLeft = project([-90, -180]);\n var topRight = project([90, 180]);\n\n return [bottomLeft, topRight];\n }\n })()\n };\n};\n\nexport default Proj4;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/geo/projection/Projection.Proj4.js\n **/","module.exports = __WEBPACK_EXTERNAL_MODULE_22__;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** external \"proj4\"\n ** module id = 22\n ** module chunks = 0\n **/","import EventEmitter from 'eventemitter3';\nimport THREE from 'three';\nimport Scene from './Scene';\nimport Renderer from './Renderer';\nimport Camera from './Camera';\n\nclass Engine extends EventEmitter {\n constructor(container) {\n console.log('Init Engine');\n\n super();\n\n this._scene = Scene;\n this._renderer = Renderer(container);\n this._camera = Camera(container);\n this.clock = new THREE.Clock();\n\n this._frustum = new THREE.Frustum();\n }\n\n update(delta) {\n this.emit('preRender');\n this._renderer.render(this._scene, this._camera);\n this.emit('postRender');\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(container) {\n return new Engine(container);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/engine/Engine.js\n **/","module.exports = __WEBPACK_EXTERNAL_MODULE_24__;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** external \"THREE\"\n ** module id = 24\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 **/","import THREE from 'three';\nimport Scene from './Scene';\n\n// This can only be accessed from Engine.renderer if you want to reference the\n// same scene in multiple places\n\nexport default function(container) {\n var renderer = new THREE.WebGLRenderer({\n antialias: true\n });\n\n // TODO: Re-enable when this works with the skybox\n // renderer.setClearColor(Scene.fog.color, 1);\n\n renderer.setClearColor(0xffffff, 1);\n\n // Gamma settings make things look nicer\n renderer.gammaInput = true;\n renderer.gammaOutput = true;\n\n renderer.shadowMap.enabled = true;\n renderer.shadowMap.cullFace = THREE.CullFaceBack;\n\n container.appendChild(renderer.domElement);\n\n var updateSize = function() {\n renderer.setSize(container.clientWidth, container.clientHeight);\n };\n\n window.addEventListener('resize', updateSize, false);\n updateSize();\n\n return renderer;\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/engine/Renderer.js\n **/","import THREE from 'three';\n\n// This can only be accessed from Engine.camera if you want to reference the\n// same scene in multiple places\n\n// TODO: Ensure that FOV looks natural on all aspect ratios\n// http://stackoverflow.com/q/26655930/997339\n\nexport default function(container) {\n var camera = new THREE.PerspectiveCamera(45, 1, 1, 200000);\n camera.position.y = 400;\n camera.position.z = 400;\n\n var updateSize = function() {\n camera.aspect = container.clientWidth / container.clientHeight;\n camera.updateProjectionMatrix();\n };\n\n window.addEventListener('resize', updateSize, false);\n updateSize();\n\n return camera;\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/engine/Camera.js\n **/","import Orbit from './Controls.Orbit';\n\nconst Controls = {\n Orbit: Orbit\n};\n\nexport default Controls;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/controls/index.js\n **/","import EventEmitter from 'eventemitter3';\nimport THREE from 'three';\nimport OrbitControls from '../vendor/OrbitControls';\n\nclass Orbit extends EventEmitter {\n constructor() {\n super();\n }\n\n // Proxy control events\n //\n // There's currently no distinction between pan, orbit and zoom events\n _initEvents() {\n this._controls.addEventListener('start', (event) => {\n this._world.emit('controlsMoveStart', event.target.target);\n });\n\n this._controls.addEventListener('change', (event) => {\n this._world.emit('controlsMove', event.target.target);\n });\n\n this._controls.addEventListener('end', (event) => {\n this._world.emit('controlsMoveEnd', event.target.target);\n });\n }\n\n // Moving the camera along the [x,y,z] axis based on a target position\n _panTo(point, animate) {}\n _panBy(pointDelta, animate) {}\n\n // Zooming the camera in and out\n _zoomTo(metres, animate) {}\n _zoomBy(metresDelta, animate) {}\n\n // Force camera to look at something other than the target\n _lookAt(point, animate) {}\n\n // Make camera look at the target\n _lookAtTarget() {}\n\n // Tilt (up and down)\n _tiltTo(angle, animate) {}\n _tiltBy(angleDelta, animate) {}\n\n // Rotate (left and right)\n _rotateTo(angle, animate) {}\n _rotateBy(angleDelta, animate) {}\n\n // Fly to the given point, animating pan and tilt/rotation to final position\n // with nice zoom out and in\n //\n // Calling flyTo a second time before the previous animation has completed\n // will immediately start the new animation from wherever the previous one\n // has got to\n _flyTo(point, noZoom) {}\n\n // Proxy to OrbitControls.update()\n update() {\n this._controls.update();\n }\n\n // Add controls to world instance and store world reference\n addTo(world) {\n world.addControls(this);\n return this;\n }\n\n // Internal method called by World.addControls to actually add the controls\n _addToWorld(world) {\n this._world = world;\n\n // TODO: Override panLeft and panUp methods to prevent panning on Y axis\n // See: http://stackoverflow.com/a/26188674/997339\n this._controls = new OrbitControls(world._engine._camera, world._container);\n\n // Disable keys for now as no events are fired for them anyway\n this._controls.keys = false;\n\n // 89 degrees\n this._controls.maxPolarAngle = 1.5533;\n\n // this._controls.enableDamping = true;\n // this._controls.dampingFactor = 0.25;\n\n this._initEvents();\n\n this.emit('added');\n }\n}\n\n// Initialise without requiring new keyword\nexport default function() {\n return new Orbit();\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/controls/Controls.Orbit.js\n **/","// jscs:disable\n/*eslint eqeqeq:0*/\n\nimport THREE from 'three';\n\n/**\n * @author qiao / https://github.com/qiao\n * @author mrdoob / http://mrdoob.com\n * @author alteredq / http://alteredqualia.com/\n * @author WestLangley / http://github.com/WestLangley\n * @author erich666 / http://erichaines.com\n */\n\n// This set of controls performs orbiting, dollying (zooming), and panning.\n// Unlike TrackballControls, it maintains the \"up\" direction object.up (+Y by default).\n//\n// Orbit - left mouse / touch: one finger move\n// Zoom - middle mouse, or mousewheel / touch: two finger spread or squish\n// Pan - right mouse, or arrow keys / touch: three finter swipe\n\nvar OrbitControls = function ( object, domElement ) {\n\n\tthis.object = object;\n\n\tthis.domElement = ( domElement !== undefined ) ? domElement : document;\n\n\t// Set to false to disable this control\n\tthis.enabled = true;\n\n\t// \"target\" sets the location of focus, where the object orbits around\n\tthis.target = new THREE.Vector3();\n\n\t// How far you can dolly in and out ( PerspectiveCamera only )\n\tthis.minDistance = 0;\n\tthis.maxDistance = Infinity;\n\n\t// How far you can zoom in and out ( OrthographicCamera only )\n\tthis.minZoom = 0;\n\tthis.maxZoom = Infinity;\n\n\t// How far you can orbit vertically, upper and lower limits.\n\t// Range is 0 to Math.PI radians.\n\tthis.minPolarAngle = 0; // radians\n\tthis.maxPolarAngle = Math.PI; // radians\n\n\t// How far you can orbit horizontally, upper and lower limits.\n\t// If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].\n\tthis.minAzimuthAngle = - Infinity; // radians\n\tthis.maxAzimuthAngle = Infinity; // radians\n\n\t// Set to true to enable damping (inertia)\n\t// If damping is enabled, you must call controls.update() in your animation loop\n\tthis.enableDamping = false;\n\tthis.dampingFactor = 0.25;\n\n\t// This option actually enables dollying in and out; left as \"zoom\" for backwards compatibility.\n\t// Set to false to disable zooming\n\tthis.enableZoom = true;\n\tthis.zoomSpeed = 1.0;\n\n\t// Set to false to disable rotating\n\tthis.enableRotate = true;\n\tthis.rotateSpeed = 1.0;\n\n\t// Set to false to disable panning\n\tthis.enablePan = true;\n\tthis.keyPanSpeed = 7.0;\t// pixels moved per arrow key push\n\n\t// Set to true to automatically rotate around the target\n\t// If auto-rotate is enabled, you must call controls.update() in your animation loop\n\tthis.autoRotate = false;\n\tthis.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60\n\n\t// Set to false to disable use of the keys\n\tthis.enableKeys = true;\n\n\t// The four arrow keys\n\tthis.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };\n\n\t// Mouse buttons\n\tthis.mouseButtons = { ORBIT: THREE.MOUSE.LEFT, ZOOM: THREE.MOUSE.MIDDLE, PAN: THREE.MOUSE.RIGHT };\n\n\t// for reset\n\tthis.target0 = this.target.clone();\n\tthis.position0 = this.object.position.clone();\n\tthis.zoom0 = this.object.zoom;\n\n\t//\n\t// public methods\n\t//\n\n\tthis.getPolarAngle = function () {\n\n\t\treturn phi;\n\n\t};\n\n\tthis.getAzimuthalAngle = function () {\n\n\t\treturn theta;\n\n\t};\n\n\tthis.reset = function () {\n\n\t\tscope.target.copy( scope.target0 );\n\t\tscope.object.position.copy( scope.position0 );\n\t\tscope.object.zoom = scope.zoom0;\n\n\t\tscope.object.updateProjectionMatrix();\n\t\tscope.dispatchEvent( changeEvent );\n\n\t\tscope.update();\n\n\t\tstate = STATE.NONE;\n\n\t};\n\n\t// this method is exposed, but perhaps it would be better if we can make it private...\n\tthis.update = function() {\n\n\t\tvar offset = new THREE.Vector3();\n\n\t\t// so camera.up is the orbit axis\n\t\tvar quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) );\n\t\tvar quatInverse = quat.clone().inverse();\n\n\t\tvar lastPosition = new THREE.Vector3();\n\t\tvar lastQuaternion = new THREE.Quaternion();\n\n\t\treturn function () {\n\n\t\t\tvar position = scope.object.position;\n\n\t\t\toffset.copy( position ).sub( scope.target );\n\n\t\t\t// rotate offset to \"y-axis-is-up\" space\n\t\t\toffset.applyQuaternion( quat );\n\n\t\t\t// angle from z-axis around y-axis\n\n\t\t\ttheta = Math.atan2( offset.x, offset.z );\n\n\t\t\t// angle from y-axis\n\n\t\t\tphi = Math.atan2( Math.sqrt( offset.x * offset.x + offset.z * offset.z ), offset.y );\n\n\t\t\tif ( scope.autoRotate && state === STATE.NONE ) {\n\n\t\t\t\trotateLeft( getAutoRotationAngle() );\n\n\t\t\t}\n\n\t\t\ttheta += thetaDelta;\n\t\t\tphi += phiDelta;\n\n\t\t\t// restrict theta to be between desired limits\n\t\t\ttheta = Math.max( scope.minAzimuthAngle, Math.min( scope.maxAzimuthAngle, theta ) );\n\n\t\t\t// restrict phi to be between desired limits\n\t\t\tphi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, phi ) );\n\n\t\t\t// restrict phi to be betwee EPS and PI-EPS\n\t\t\tphi = Math.max( EPS, Math.min( Math.PI - EPS, phi ) );\n\n\t\t\tvar radius = offset.length() * scale;\n\n\t\t\t// restrict radius to be between desired limits\n\t\t\tradius = Math.max( scope.minDistance, Math.min( scope.maxDistance, radius ) );\n\n\t\t\t// move target to panned location\n\t\t\tscope.target.add( panOffset );\n\n\t\t\toffset.x = radius * Math.sin( phi ) * Math.sin( theta );\n\t\t\toffset.y = radius * Math.cos( phi );\n\t\t\toffset.z = radius * Math.sin( phi ) * Math.cos( theta );\n\n\t\t\t// rotate offset back to \"camera-up-vector-is-up\" space\n\t\t\toffset.applyQuaternion( quatInverse );\n\n\t\t\tposition.copy( scope.target ).add( offset );\n\n\t\t\tscope.object.lookAt( scope.target );\n\n\t\t\tif ( scope.enableDamping === true ) {\n\n\t\t\t\tthetaDelta *= ( 1 - scope.dampingFactor );\n\t\t\t\tphiDelta *= ( 1 - scope.dampingFactor );\n\n\t\t\t} else {\n\n\t\t\t\tthetaDelta = 0;\n\t\t\t\tphiDelta = 0;\n\n\t\t\t}\n\n\t\t\tscale = 1;\n\t\t\tpanOffset.set( 0, 0, 0 );\n\n\t\t\t// update condition is:\n\t\t\t// min(camera displacement, camera rotation in radians)^2 > EPS\n\t\t\t// using small-angle approximation cos(x/2) = 1 - x^2 / 8\n\n\t\t\tif ( zoomChanged ||\n\t\t\t\tlastPosition.distanceToSquared( scope.object.position ) > EPS ||\n\t\t\t\t8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ) {\n\n\t\t\t\tscope.dispatchEvent( changeEvent );\n\n\t\t\t\tlastPosition.copy( scope.object.position );\n\t\t\t\tlastQuaternion.copy( scope.object.quaternion );\n\t\t\t\tzoomChanged = false;\n\n\t\t\t\treturn true;\n\n\t\t\t}\n\n\t\t\treturn false;\n\n\t\t};\n\n\t}();\n\n\tthis.dispose = function() {\n\n\t\tscope.domElement.removeEventListener( 'contextmenu', onContextMenu, false );\n\t\tscope.domElement.removeEventListener( 'mousedown', onMouseDown, false );\n\t\tscope.domElement.removeEventListener( 'mousewheel', onMouseWheel, false );\n\t\tscope.domElement.removeEventListener( 'MozMousePixelScroll', onMouseWheel, false ); // firefox\n\n\t\tscope.domElement.removeEventListener( 'touchstart', onTouchStart, false );\n\t\tscope.domElement.removeEventListener( 'touchend', onTouchEnd, false );\n\t\tscope.domElement.removeEventListener( 'touchmove', onTouchMove, false );\n\n\t\tdocument.removeEventListener( 'mousemove', onMouseMove, false );\n\t\tdocument.removeEventListener( 'mouseup', onMouseUp, false );\n\t\tdocument.removeEventListener( 'mouseout', onMouseUp, false );\n\n\t\twindow.removeEventListener( 'keydown', onKeyDown, false );\n\n\t\t//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?\n\n\t};\n\n\t//\n\t// internals\n\t//\n\n\tvar scope = this;\n\n\tvar changeEvent = { type: 'change' };\n\tvar startEvent = { type: 'start' };\n\tvar endEvent = { type: 'end' };\n\n\tvar STATE = { NONE : - 1, ROTATE : 0, DOLLY : 1, PAN : 2, TOUCH_ROTATE : 3, TOUCH_DOLLY : 4, TOUCH_PAN : 5 };\n\n\tvar state = STATE.NONE;\n\n\tvar EPS = 0.000001;\n\n\t// current position in spherical coordinates\n\tvar theta;\n\tvar phi;\n\n\tvar phiDelta = 0;\n\tvar thetaDelta = 0;\n\tvar scale = 1;\n\tvar panOffset = new THREE.Vector3();\n\tvar zoomChanged = false;\n\n\tvar rotateStart = new THREE.Vector2();\n\tvar rotateEnd = new THREE.Vector2();\n\tvar rotateDelta = new THREE.Vector2();\n\n\tvar panStart = new THREE.Vector2();\n\tvar panEnd = new THREE.Vector2();\n\tvar panDelta = new THREE.Vector2();\n\n\tvar dollyStart = new THREE.Vector2();\n\tvar dollyEnd = new THREE.Vector2();\n\tvar dollyDelta = new THREE.Vector2();\n\n\tfunction getAutoRotationAngle() {\n\n\t\treturn 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;\n\n\t}\n\n\tfunction getZoomScale() {\n\n\t\treturn Math.pow( 0.95, scope.zoomSpeed );\n\n\t}\n\n\tfunction rotateLeft( angle ) {\n\n\t\tthetaDelta -= angle;\n\n\t}\n\n\tfunction rotateUp( angle ) {\n\n\t\tphiDelta -= angle;\n\n\t}\n\n\tvar panLeft = function() {\n\n\t\tvar v = new THREE.Vector3();\n\n\t\t// return function panLeft( distance, objectMatrix ) {\n //\n\t\t// \tvar te = objectMatrix.elements;\n //\n\t\t// \t// get X column of objectMatrix\n\t\t// \tv.set( te[ 0 ], te[ 1 ], te[ 2 ] );\n //\n\t\t// \tv.multiplyScalar( - distance );\n //\n\t\t// \tpanOffset.add( v );\n //\n\t\t// };\n\n // Fixed panning to x/y plane\n return function panLeft(distance, objectMatrix) {\n\t var te = objectMatrix.elements;\n\t // var adjDist = distance / Math.cos(phi);\n\n\t v.set(te[ 0 ], 0, te[ 2 ]);\n\t v.multiplyScalar(-distance);\n\n\t panOffset.add(v);\n\t };\n\n\t}();\n\n // Fixed panning to x/y plane\n\tvar panUp = function() {\n\n\t\tvar v = new THREE.Vector3();\n\n\t\t// return function panUp( distance, objectMatrix ) {\n //\n\t\t// \tvar te = objectMatrix.elements;\n //\n\t\t// \t// get Y column of objectMatrix\n\t\t// \tv.set( te[ 4 ], te[ 5 ], te[ 6 ] );\n //\n\t\t// \tv.multiplyScalar( distance );\n //\n\t\t// \tpanOffset.add( v );\n //\n\t\t// };\n\n return function panUp(distance, objectMatrix) {\n\t var te = objectMatrix.elements;\n\t var adjDist = distance / Math.cos(phi);\n\n\t v.set(te[ 4 ], 0, te[ 6 ]);\n\t v.multiplyScalar(adjDist);\n\n\t panOffset.add(v);\n\t };\n\n\t}();\n\n\t// deltaX and deltaY are in pixels; right and down are positive\n\tvar pan = function() {\n\n\t\tvar offset = new THREE.Vector3();\n\n\t\treturn function( deltaX, deltaY ) {\n\n\t\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t\tif ( scope.object instanceof THREE.PerspectiveCamera ) {\n\n\t\t\t\t// perspective\n\t\t\t\tvar position = scope.object.position;\n\t\t\t\toffset.copy( position ).sub( scope.target );\n\t\t\t\tvar targetDistance = offset.length();\n\n\t\t\t\t// half of the fov is center to top of screen\n\t\t\t\ttargetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );\n\n\t\t\t\t// we actually don't use screenWidth, since perspective camera is fixed to screen height\n\t\t\t\tpanLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix );\n\t\t\t\tpanUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix );\n\n\t\t\t} else if ( scope.object instanceof THREE.OrthographicCamera ) {\n\n\t\t\t\t// orthographic\n\t\t\t\tpanLeft( deltaX * ( scope.object.right - scope.object.left ) / element.clientWidth, scope.object.matrix );\n\t\t\t\tpanUp( deltaY * ( scope.object.top - scope.object.bottom ) / element.clientHeight, scope.object.matrix );\n\n\t\t\t} else {\n\n\t\t\t\t// camera neither orthographic nor perspective\n\t\t\t\tconsole.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );\n\t\t\t\tscope.enablePan = false;\n\n\t\t\t}\n\n\t\t};\n\n\t}();\n\n\tfunction dollyIn( dollyScale ) {\n\n\t\tif ( scope.object instanceof THREE.PerspectiveCamera ) {\n\n\t\t\tscale /= dollyScale;\n\n\t\t} else if ( scope.object instanceof THREE.OrthographicCamera ) {\n\n\t\t\tscope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom * dollyScale ) );\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tzoomChanged = true;\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );\n\t\t\tscope.enableZoom = false;\n\n\t\t}\n\n\t}\n\n\tfunction dollyOut( dollyScale ) {\n\n\t\tif ( scope.object instanceof THREE.PerspectiveCamera ) {\n\n\t\t\tscale *= dollyScale;\n\n\t\t} else if ( scope.object instanceof THREE.OrthographicCamera ) {\n\n\t\t\tscope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / dollyScale ) );\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tzoomChanged = true;\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );\n\t\t\tscope.enableZoom = false;\n\n\t\t}\n\n\t}\n\n\t//\n\t// event callbacks - update the object state\n\t//\n\n\tfunction handleMouseDownRotate( event ) {\n\n\t\t//console.log( 'handleMouseDownRotate' );\n\n\t\trotateStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseDownDolly( event ) {\n\n\t\t//console.log( 'handleMouseDownDolly' );\n\n\t\tdollyStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseDownPan( event ) {\n\n\t\t//console.log( 'handleMouseDownPan' );\n\n\t\tpanStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseMoveRotate( event ) {\n\n\t\t//console.log( 'handleMouseMoveRotate' );\n\n\t\trotateEnd.set( event.clientX, event.clientY );\n\t\trotateDelta.subVectors( rotateEnd, rotateStart );\n\n\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t// rotating across whole screen goes 360 degrees around\n\t\trotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );\n\n\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\trotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );\n\n\t\trotateStart.copy( rotateEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseMoveDolly( event ) {\n\n\t\t//console.log( 'handleMouseMoveDolly' );\n\n\t\tdollyEnd.set( event.clientX, event.clientY );\n\n\t\tdollyDelta.subVectors( dollyEnd, dollyStart );\n\n\t\tif ( dollyDelta.y > 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t} else if ( dollyDelta.y < 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t}\n\n\t\tdollyStart.copy( dollyEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseMovePan( event ) {\n\n\t\t//console.log( 'handleMouseMovePan' );\n\n\t\tpanEnd.set( event.clientX, event.clientY );\n\n\t\tpanDelta.subVectors( panEnd, panStart );\n\n\t\tpan( panDelta.x, panDelta.y );\n\n\t\tpanStart.copy( panEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseUp( event ) {\n\n\t\t//console.log( 'handleMouseUp' );\n\n\t}\n\n\tfunction handleMouseWheel( event ) {\n\n\t\t//console.log( 'handleMouseWheel' );\n\n\t\tvar delta = 0;\n\n\t\tif ( event.wheelDelta !== undefined ) {\n\n\t\t\t// WebKit / Opera / Explorer 9\n\n\t\t\tdelta = event.wheelDelta;\n\n\t\t} else if ( event.detail !== undefined ) {\n\n\t\t\t// Firefox\n\n\t\t\tdelta = - event.detail;\n\n\t\t}\n\n\t\tif ( delta > 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t} else if ( delta < 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t}\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleKeyDown( event ) {\n\n\t\t//console.log( 'handleKeyDown' );\n\n\t\tswitch ( event.keyCode ) {\n\n\t\t\tcase scope.keys.UP:\n\t\t\t\tpan( 0, scope.keyPanSpeed );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.BOTTOM:\n\t\t\t\tpan( 0, - scope.keyPanSpeed );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.LEFT:\n\t\t\t\tpan( scope.keyPanSpeed, 0 );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.RIGHT:\n\t\t\t\tpan( - scope.keyPanSpeed, 0 );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\tfunction handleTouchStartRotate( event ) {\n\n\t\t//console.log( 'handleTouchStartRotate' );\n\n\t\trotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t}\n\n\tfunction handleTouchStartDolly( event ) {\n\n\t\t//console.log( 'handleTouchStartDolly' );\n\n\t\tvar dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;\n\t\tvar dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;\n\n\t\tvar distance = Math.sqrt( dx * dx + dy * dy );\n\n\t\tdollyStart.set( 0, distance );\n\n\t}\n\n\tfunction handleTouchStartPan( event ) {\n\n\t\t//console.log( 'handleTouchStartPan' );\n\n\t\tpanStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t}\n\n\tfunction handleTouchMoveRotate( event ) {\n\n\t\t//console.log( 'handleTouchMoveRotate' );\n\n\t\trotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\t\trotateDelta.subVectors( rotateEnd, rotateStart );\n\n\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t// rotating across whole screen goes 360 degrees around\n\t\trotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );\n\n\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\trotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );\n\n\t\trotateStart.copy( rotateEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchMoveDolly( event ) {\n\n\t\t//console.log( 'handleTouchMoveDolly' );\n\n\t\tvar dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;\n\t\tvar dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;\n\n\t\tvar distance = Math.sqrt( dx * dx + dy * dy );\n\n\t\tdollyEnd.set( 0, distance );\n\n\t\tdollyDelta.subVectors( dollyEnd, dollyStart );\n\n\t\tif ( dollyDelta.y > 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t} else if ( dollyDelta.y < 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t}\n\n\t\tdollyStart.copy( dollyEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchMovePan( event ) {\n\n\t\t//console.log( 'handleTouchMovePan' );\n\n\t\tpanEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t\tpanDelta.subVectors( panEnd, panStart );\n\n\t\tpan( panDelta.x, panDelta.y );\n\n\t\tpanStart.copy( panEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchEnd( event ) {\n\n\t\t//console.log( 'handleTouchEnd' );\n\n\t}\n\n\t//\n\t// event handlers - FSM: listen for events and reset state\n\t//\n\n\tfunction onMouseDown( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t\tif ( event.button === scope.mouseButtons.ORBIT ) {\n\n\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\thandleMouseDownRotate( event );\n\n\t\t\tstate = STATE.ROTATE;\n\n\t\t} else if ( event.button === scope.mouseButtons.ZOOM ) {\n\n\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\thandleMouseDownDolly( event );\n\n\t\t\tstate = STATE.DOLLY;\n\n\t\t} else if ( event.button === scope.mouseButtons.PAN ) {\n\n\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\thandleMouseDownPan( event );\n\n\t\t\tstate = STATE.PAN;\n\n\t\t}\n\n\t\tif ( state !== STATE.NONE ) {\n\n\t\t\tdocument.addEventListener( 'mousemove', onMouseMove, false );\n\t\t\tdocument.addEventListener( 'mouseup', onMouseUp, false );\n\t\t\tdocument.addEventListener( 'mouseout', onMouseUp, false );\n\n\t\t\tscope.dispatchEvent( startEvent );\n\n\t\t}\n\n\t}\n\n\tfunction onMouseMove( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t\tif ( state === STATE.ROTATE ) {\n\n\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\thandleMouseMoveRotate( event );\n\n\t\t} else if ( state === STATE.DOLLY ) {\n\n\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\thandleMouseMoveDolly( event );\n\n\t\t} else if ( state === STATE.PAN ) {\n\n\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\thandleMouseMovePan( event );\n\n\t\t}\n\n\t}\n\n\tfunction onMouseUp( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\thandleMouseUp( event );\n\n\t\tdocument.removeEventListener( 'mousemove', onMouseMove, false );\n\t\tdocument.removeEventListener( 'mouseup', onMouseUp, false );\n\t\tdocument.removeEventListener( 'mouseout', onMouseUp, false );\n\n\t\tscope.dispatchEvent( endEvent );\n\n\t\tstate = STATE.NONE;\n\n\t}\n\n\tfunction onMouseWheel( event ) {\n\n\t\tif ( scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE ) return;\n\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\n\t\thandleMouseWheel( event );\n\n\t\tscope.dispatchEvent( startEvent ); // not sure why these are here...\n\t\tscope.dispatchEvent( endEvent );\n\n\t}\n\n\tfunction onKeyDown( event ) {\n\n\t\tif ( scope.enabled === false || scope.enableKeys === false || scope.enablePan === false ) return;\n\n\t\thandleKeyDown( event );\n\n\t}\n\n\tfunction onTouchStart( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tswitch ( event.touches.length ) {\n\n\t\t\tcase 1:\t// one-fingered touch: rotate\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleTouchStartRotate( event );\n\n\t\t\t\tstate = STATE.TOUCH_ROTATE;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 2:\t// two-fingered touch: dolly\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleTouchStartDolly( event );\n\n\t\t\t\tstate = STATE.TOUCH_DOLLY;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 3: // three-fingered touch: pan\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleTouchStartPan( event );\n\n\t\t\t\tstate = STATE.TOUCH_PAN;\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tstate = STATE.NONE;\n\n\t\t}\n\n\t\tif ( state !== STATE.NONE ) {\n\n\t\t\tscope.dispatchEvent( startEvent );\n\n\t\t}\n\n\t}\n\n\tfunction onTouchMove( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\n\t\tswitch ( event.touches.length ) {\n\n\t\t\tcase 1: // one-fingered touch: rotate\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_ROTATE ) return; // is this needed?...\n\n\t\t\t\thandleTouchMoveRotate( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 2: // two-fingered touch: dolly\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_DOLLY ) return; // is this needed?...\n\n\t\t\t\thandleTouchMoveDolly( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 3: // three-fingered touch: pan\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_PAN ) return; // is this needed?...\n\n\t\t\t\thandleTouchMovePan( event );\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tstate = STATE.NONE;\n\n\t\t}\n\n\t}\n\n\tfunction onTouchEnd( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\thandleTouchEnd( event );\n\n\t\tscope.dispatchEvent( endEvent );\n\n\t\tstate = STATE.NONE;\n\n\t}\n\n\tfunction onContextMenu( event ) {\n\n\t\tevent.preventDefault();\n\n\t}\n\n\t//\n\n\tscope.domElement.addEventListener( 'contextmenu', onContextMenu, false );\n\n\tscope.domElement.addEventListener( 'mousedown', onMouseDown, false );\n\tscope.domElement.addEventListener( 'mousewheel', onMouseWheel, false );\n\tscope.domElement.addEventListener( 'MozMousePixelScroll', onMouseWheel, false ); // firefox\n\n\tscope.domElement.addEventListener( 'touchstart', onTouchStart, false );\n\tscope.domElement.addEventListener( 'touchend', onTouchEnd, false );\n\tscope.domElement.addEventListener( 'touchmove', onTouchMove, false );\n\n\twindow.addEventListener( 'keydown', onKeyDown, false );\n\n\t// force an update at start\n\n\tthis.update();\n\n};\n\nOrbitControls.prototype = Object.create( THREE.EventDispatcher.prototype );\nOrbitControls.prototype.constructor = THREE.OrbitControls;\n\nObject.defineProperties( OrbitControls.prototype, {\n\n\tcenter: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .center has been renamed to .target' );\n\t\t\treturn this.target;\n\n\t\t}\n\n\t},\n\n\t// backward compatibility\n\n\tnoZoom: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' );\n\t\t\treturn ! this.enableZoom;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' );\n\t\t\tthis.enableZoom = ! value;\n\n\t\t}\n\n\t},\n\n\tnoRotate: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' );\n\t\t\treturn ! this.enableRotate;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' );\n\t\t\tthis.enableRotate = ! value;\n\n\t\t}\n\n\t},\n\n\tnoPan: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noPan has been deprecated. Use .enablePan instead.' );\n\t\t\treturn ! this.enablePan;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noPan has been deprecated. Use .enablePan instead.' );\n\t\t\tthis.enablePan = ! value;\n\n\t\t}\n\n\t},\n\n\tnoKeys: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' );\n\t\t\treturn ! this.enableKeys;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' );\n\t\t\tthis.enableKeys = ! value;\n\n\t\t}\n\n\t},\n\n\tstaticMoving : {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' );\n\t\t\treturn ! this.constraint.enableDamping;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' );\n\t\t\tthis.constraint.enableDamping = ! value;\n\n\t\t}\n\n\t},\n\n\tdynamicDampingFactor : {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' );\n\t\t\treturn this.constraint.dampingFactor;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'THREE.OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' );\n\t\t\tthis.constraint.dampingFactor = value;\n\n\t\t}\n\n\t}\n\n} );\n\nexport default OrbitControls;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/vendor/OrbitControls.js\n **/","import Layer from '../Layer';\nimport extend from 'lodash.assign';\nimport THREE from 'three';\nimport Skybox from './Skybox';\n\nclass EnvironmentLayer extends Layer {\n constructor(options) {\n super();\n\n var defaults = {\n skybox: false\n };\n\n this._options = extend(defaults, options);\n }\n\n _onAdd() {\n this._initLights();\n\n if (this._options.skybox) {\n this._initSkybox();\n }\n\n // this._initGrid();\n }\n\n // Not fleshed out or thought through yet\n //\n // Lights could potentially be put it their own 'layer' to keep this class\n // much simpler and less messy\n _initLights() {\n // Position doesn't really matter (the angle is important), however it's\n // used here so the helpers look more natural.\n\n if (!this._options.skybox) {\n var directionalLight = new THREE.DirectionalLight(0x999999);\n directionalLight.intesity = 0.1;\n directionalLight.position.x = 100;\n directionalLight.position.y = 100;\n directionalLight.position.z = 100;\n\n var directionalLight2 = new THREE.DirectionalLight(0x999999);\n directionalLight2.intesity = 0.1;\n directionalLight2.position.x = -100;\n directionalLight2.position.y = 100;\n directionalLight2.position.z = -100;\n\n var helper = new THREE.DirectionalLightHelper(directionalLight, 10);\n var helper2 = new THREE.DirectionalLightHelper(directionalLight2, 10);\n\n this.add(directionalLight);\n this.add(directionalLight2);\n\n this.add(helper);\n this.add(helper2);\n } else {\n // Directional light that will be projected from the sun\n this._skyboxLight = new THREE.DirectionalLight(0xffffff, 1);\n\n this._skyboxLight.castShadow = true;\n\n var d = 1000;\n this._skyboxLight.shadow.camera.left = -d;\n this._skyboxLight.shadow.camera.right = d;\n this._skyboxLight.shadow.camera.top = d;\n this._skyboxLight.shadow.camera.bottom = -d;\n\n this._skyboxLight.shadow.camera.near = 10000;\n this._skyboxLight.shadow.camera.far = 70000;\n\n // TODO: Need to dial in on a good shadowmap size\n this._skyboxLight.shadow.mapSize.width = 2048;\n this._skyboxLight.shadow.mapSize.height = 2048;\n\n // this._skyboxLight.shadowBias = -0.0010;\n // this._skyboxLight.shadow.darkness = 0.15;\n\n // this._layer.add(new THREE.CameraHelper(this._skyboxLight.shadow.camera));\n\n this.add(this._skyboxLight);\n }\n }\n\n _initSkybox() {\n this._skybox = Skybox(this._world, this._skyboxLight);\n this.add(this._skybox._mesh);\n }\n\n // Add grid helper for context during initial development\n _initGrid() {\n var size = 4000;\n var step = 100;\n\n var gridHelper = new THREE.GridHelper(size, step);\n this.add(gridHelper);\n }\n\n // Clean up environment\n destroy() {\n this._skyboxLight = null;\n\n this.remove(this._skybox._mesh);\n this._skybox.destroy();\n this._skybox = null;\n\n super.destroy();\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(options) {\n return new EnvironmentLayer(options);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/environment/EnvironmentLayer.js\n **/","import EventEmitter from 'eventemitter3';\nimport THREE from 'three';\nimport Scene from '../engine/Scene';\n\nclass Layer extends EventEmitter {\n constructor() {\n super();\n\n this._layer = new THREE.Object3D();\n }\n\n // Add THREE object directly to layer\n add(object) {\n this._layer.add(object);\n }\n\n // Remove THREE object from to layer\n remove(object) {\n this._layer.remove(object);\n }\n\n // Add layer to world instance and store world reference\n addTo(world) {\n world.addLayer(this);\n return this;\n }\n\n // Internal method called by World.addLayer to actually add the layer\n _addToWorld(world) {\n this._world = world;\n this._onAdd(world);\n this.emit('added');\n }\n\n // Destroys the layer and removes it from the scene and memory\n destroy() {\n // Remove everything else in the layer\n var child;\n for (i = this._layer.children.length - 1; i >= 0; i--) {\n child = this._layer.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 this._world = null;\n this._layer = null;\n }\n}\n\nexport default Layer;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/Layer.js\n **/","import THREE from 'three';\nimport Sky from './Sky';\nimport throttle from 'lodash.throttle';\n\nvar cubemap = {\n vertexShader: [\n\t\t'varying vec3 vPosition;',\n\t\t'void main() {',\n\t\t\t'vPosition = position;',\n\t\t\t'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',\n\t\t'}'\n\t].join('\\n'),\n\n fragmentShader: [\n 'uniform samplerCube cubemap;',\n 'varying vec3 vPosition;',\n\n 'void main() {',\n 'gl_FragColor = textureCube(cubemap, normalize(vPosition));',\n '}'\n ].join('\\n')\n};\n\nclass Skybox {\n constructor(world, light) {\n this._world = world;\n this._light = light;\n\n this._settings = {\n distance: 38000,\n turbidity: 10,\n reileigh: 2,\n mieCoefficient: 0.005,\n mieDirectionalG: 0.8,\n luminance: 1,\n // 0.48 is a cracking dusk / sunset\n // 0.4 is a beautiful early-morning / late-afternoon\n // 0.2 is a nice day time\n inclination: 0.48, // Elevation / inclination\n azimuth: 0.25, // Facing front\n };\n\n this._initSkybox();\n this._updateUniforms();\n this._initEvents();\n }\n\n _initEvents() {\n // Throttled to 1 per 100ms\n this._throttledWorldUpdate = throttle(this._update, 100);\n this._world.on('preUpdate', this._throttledWorldUpdate, this);\n }\n\n _initSkybox() {\n // Cube camera for skybox\n this._cubeCamera = new THREE.CubeCamera(1, 2000000, 128);\n\n // Cube material\n var cubeTarget = this._cubeCamera.renderTarget;\n\n // Add Sky Mesh\n this._sky = new Sky();\n this._skyScene = new THREE.Scene();\n this._skyScene.add(this._sky.mesh);\n\n // Add Sun Helper\n this._sunSphere = new THREE.Mesh(\n new THREE.SphereBufferGeometry(2000, 16, 8),\n new THREE.MeshBasicMaterial({\n color: 0xffffff\n })\n );\n\n // TODO: This isn't actually visible because it's not added to the layer\n // this._sunSphere.visible = true;\n\n var skyboxUniforms = {\n cubemap: { type: 't', value: cubeTarget }\n };\n\n var skyboxMat = new THREE.ShaderMaterial({\n uniforms: skyboxUniforms,\n vertexShader: cubemap.vertexShader,\n fragmentShader: cubemap.fragmentShader,\n side: THREE.BackSide\n });\n\n this._mesh = new THREE.Mesh(new THREE.BoxGeometry(190000, 190000, 190000), skyboxMat);\n }\n\n _updateUniforms() {\n var settings = this._settings;\n var uniforms = this._sky.uniforms;\n uniforms.turbidity.value = settings.turbidity;\n uniforms.reileigh.value = settings.reileigh;\n uniforms.luminance.value = settings.luminance;\n uniforms.mieCoefficient.value = settings.mieCoefficient;\n uniforms.mieDirectionalG.value = settings.mieDirectionalG;\n\n var theta = Math.PI * (settings.inclination - 0.5);\n var phi = 2 * Math.PI * (settings.azimuth - 0.5);\n\n this._sunSphere.position.x = settings.distance * Math.cos(phi);\n this._sunSphere.position.y = settings.distance * Math.sin(phi) * Math.sin(theta);\n this._sunSphere.position.z = settings.distance * Math.sin(phi) * Math.cos(theta);\n\n // Move directional light to sun position\n this._light.position.copy(this._sunSphere.position);\n\n this._sky.uniforms.sunPosition.value.copy(this._sunSphere.position);\n }\n\n _update(delta) {\n if (!this._done) {\n this._done = true;\n } else {\n return;\n }\n\n // if (!this._angle) {\n // this._angle = 0;\n // }\n //\n // // Animate inclination\n // this._angle += Math.PI * delta;\n // this._settings.inclination = 0.5 * (Math.sin(this._angle) / 2 + 0.5);\n\n // Update light intensity depending on elevation of sun (day to night)\n this._light.intensity = 1 - 0.95 * (this._settings.inclination / 0.5);\n\n // // console.log(delta, this._angle, this._settings.inclination);\n //\n // TODO: Only do this when the uniforms have been changed\n this._updateUniforms();\n\n // TODO: Only do this when the cubemap has actually changed\n this._cubeCamera.updateCubeMap(this._world._engine._renderer, this._skyScene);\n }\n\n getRenderTarget() {\n return this._cubeCamera.renderTarget;\n }\n\n // Destroy the skybox and remove it from memory\n destroy() {\n this._world.off('preUpdate', this._throttledWorldUpdate);\n this._throttledWorldUpdate = null;\n\n this._world = null;\n this._light = null;\n\n this._cubeCamera = null;\n\n this._sky.mesh.geometry.dispose();\n this._sky.mesh.geometry = null;\n\n if (this._sky.mesh.material.map) {\n this._sky.mesh.material.map.dispose();\n this._sky.mesh.material.map = null;\n }\n\n this._sky.mesh.material.dispose();\n this._sky.mesh.material = null;\n\n this._sky.mesh = null;\n this._sky = null;\n\n this._skyScene = null;\n\n this._sunSphere.geometry.dispose();\n this._sunSphere.geometry = null;\n\n if (this._sunSphere.material.map) {\n this._sunSphere.material.map.dispose();\n this._sunSphere.material.map = null;\n }\n\n this._sunSphere.material.dispose();\n this._sunSphere.material = null;\n\n this._sunSphere = null;\n\n this._mesh.geometry.dispose();\n this._mesh.geometry = null;\n\n if (this._mesh.material.map) {\n this._mesh.material.map.dispose();\n this._mesh.material.map = null;\n }\n\n this._mesh.material.dispose();\n this._mesh.material = null;\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(world, light) {\n return new Skybox(world, light);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/environment/Skybox.js\n **/","// jscs:disable\n/*eslint eqeqeq:0*/\n\n/**\n * @author zz85 / https://github.com/zz85\n *\n * Based on 'A Practical Analytic Model for Daylight'\n * aka The Preetham Model, the de facto standard analytic skydome model\n * http://www.cs.utah.edu/~shirley/papers/sunsky/sunsky.pdf\n *\n * First implemented by Simon Wallner\n * http://www.simonwallner.at/projects/atmospheric-scattering\n *\n * Improved by Martin Upitis\n * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR\n *\n * Three.js integration by zz85 http://twitter.com/blurspline\n*/\n\nimport THREE from 'three';\n\nTHREE.ShaderLib[ 'sky' ] = {\n\n\tuniforms: {\n\n\t\tluminance:\t { type: 'f', value: 1 },\n\t\tturbidity:\t { type: 'f', value: 2 },\n\t\treileigh:\t { type: 'f', value: 1 },\n\t\tmieCoefficient:\t { type: 'f', value: 0.005 },\n\t\tmieDirectionalG: { type: 'f', value: 0.8 },\n\t\tsunPosition: \t { type: 'v3', value: new THREE.Vector3() }\n\n\t},\n\n\tvertexShader: [\n\n\t\t'varying vec3 vWorldPosition;',\n\n\t\t'void main() {',\n\n\t\t\t'vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',\n\t\t\t'vWorldPosition = worldPosition.xyz;',\n\n\t\t\t'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',\n\n\t\t'}',\n\n\t].join( '\\n' ),\n\n\tfragmentShader: [\n\n\t\t'uniform sampler2D skySampler;',\n\t\t'uniform vec3 sunPosition;',\n\t\t'varying vec3 vWorldPosition;',\n\n\t\t'vec3 cameraPos = vec3(0., 0., 0.);',\n\t\t'// uniform sampler2D sDiffuse;',\n\t\t'// const float turbidity = 10.0; //',\n\t\t'// const float reileigh = 2.; //',\n\t\t'// const float luminance = 1.0; //',\n\t\t'// const float mieCoefficient = 0.005;',\n\t\t'// const float mieDirectionalG = 0.8;',\n\n\t\t'uniform float luminance;',\n\t\t'uniform float turbidity;',\n\t\t'uniform float reileigh;',\n\t\t'uniform float mieCoefficient;',\n\t\t'uniform float mieDirectionalG;',\n\n\t\t'// constants for atmospheric scattering',\n\t\t'const float e = 2.71828182845904523536028747135266249775724709369995957;',\n\t\t'const float pi = 3.141592653589793238462643383279502884197169;',\n\n\t\t'const float n = 1.0003; // refractive index of air',\n\t\t'const float N = 2.545E25; // number of molecules per unit volume for air at',\n\t\t\t\t\t\t\t\t'// 288.15K and 1013mb (sea level -45 celsius)',\n\t\t'const float pn = 0.035;\t// depolatization factor for standard air',\n\n\t\t'// wavelength of used primaries, according to preetham',\n\t\t'const vec3 lambda = vec3(680E-9, 550E-9, 450E-9);',\n\n\t\t'// mie stuff',\n\t\t'// K coefficient for the primaries',\n\t\t'const vec3 K = vec3(0.686, 0.678, 0.666);',\n\t\t'const float v = 4.0;',\n\n\t\t'// optical length at zenith for molecules',\n\t\t'const float rayleighZenithLength = 8.4E3;',\n\t\t'const float mieZenithLength = 1.25E3;',\n\t\t'const vec3 up = vec3(0.0, 1.0, 0.0);',\n\n\t\t'const float EE = 1000.0;',\n\t\t'const float sunAngularDiameterCos = 0.999956676946448443553574619906976478926848692873900859324;',\n\t\t'// 66 arc seconds -> degrees, and the cosine of that',\n\n\t\t'// earth shadow hack',\n\t\t'const float cutoffAngle = pi/1.95;',\n\t\t'const float steepness = 1.5;',\n\n\n\t\t'vec3 totalRayleigh(vec3 lambda)',\n\t\t'{',\n\t\t\t'return (8.0 * pow(pi, 3.0) * pow(pow(n, 2.0) - 1.0, 2.0) * (6.0 + 3.0 * pn)) / (3.0 * N * pow(lambda, vec3(4.0)) * (6.0 - 7.0 * pn));',\n\t\t'}',\n\n\t\t// see http://blenderartists.org/forum/showthread.php?321110-Shaders-and-Skybox-madness\n\t\t'// A simplied version of the total Reayleigh scattering to works on browsers that use ANGLE',\n\t\t'vec3 simplifiedRayleigh()',\n\t\t'{',\n\t\t\t'return 0.0005 / vec3(94, 40, 18);',\n\t\t\t// return 0.00054532832366 / (3.0 * 2.545E25 * pow(vec3(680E-9, 550E-9, 450E-9), vec3(4.0)) * 6.245);\n\t\t'}',\n\n\t\t'float rayleighPhase(float cosTheta)',\n\t\t'{\t ',\n\t\t\t'return (3.0 / (16.0*pi)) * (1.0 + pow(cosTheta, 2.0));',\n\t\t'//\treturn (1.0 / (3.0*pi)) * (1.0 + pow(cosTheta, 2.0));',\n\t\t'//\treturn (3.0 / 4.0) * (1.0 + pow(cosTheta, 2.0));',\n\t\t'}',\n\n\t\t'vec3 totalMie(vec3 lambda, vec3 K, float T)',\n\t\t'{',\n\t\t\t'float c = (0.2 * T ) * 10E-18;',\n\t\t\t'return 0.434 * c * pi * pow((2.0 * pi) / lambda, vec3(v - 2.0)) * K;',\n\t\t'}',\n\n\t\t'float hgPhase(float cosTheta, float g)',\n\t\t'{',\n\t\t\t'return (1.0 / (4.0*pi)) * ((1.0 - pow(g, 2.0)) / pow(1.0 - 2.0*g*cosTheta + pow(g, 2.0), 1.5));',\n\t\t'}',\n\n\t\t'float sunIntensity(float zenithAngleCos)',\n\t\t'{',\n\t\t\t'return EE * max(0.0, 1.0 - exp(-((cutoffAngle - acos(zenithAngleCos))/steepness)));',\n\t\t'}',\n\n\t\t'// float logLuminance(vec3 c)',\n\t\t'// {',\n\t\t'// \treturn log(c.r * 0.2126 + c.g * 0.7152 + c.b * 0.0722);',\n\t\t'// }',\n\n\t\t'// Filmic ToneMapping http://filmicgames.com/archives/75',\n\t\t'float A = 0.15;',\n\t\t'float B = 0.50;',\n\t\t'float C = 0.10;',\n\t\t'float D = 0.20;',\n\t\t'float E = 0.02;',\n\t\t'float F = 0.30;',\n\t\t'float W = 1000.0;',\n\n\t\t'vec3 Uncharted2Tonemap(vec3 x)',\n\t\t'{',\n\t\t 'return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;',\n\t\t'}',\n\n\n\t\t'void main() ',\n\t\t'{',\n\t\t\t'float sunfade = 1.0-clamp(1.0-exp((sunPosition.y/450000.0)),0.0,1.0);',\n\n\t\t\t'// luminance = 1.0 ;// vWorldPosition.y / 450000. + 0.5; //sunPosition.y / 450000. * 1. + 0.5;',\n\n\t\t\t '// gl_FragColor = vec4(sunfade, sunfade, sunfade, 1.0);',\n\n\t\t\t'float reileighCoefficient = reileigh - (1.0* (1.0-sunfade));',\n\n\t\t\t'vec3 sunDirection = normalize(sunPosition);',\n\n\t\t\t'float sunE = sunIntensity(dot(sunDirection, up));',\n\n\t\t\t'// extinction (absorbtion + out scattering) ',\n\t\t\t'// rayleigh coefficients',\n\n\t\t\t// 'vec3 betaR = totalRayleigh(lambda) * reileighCoefficient;',\n\t\t\t'vec3 betaR = simplifiedRayleigh() * reileighCoefficient;',\n\n\t\t\t'// mie coefficients',\n\t\t\t'vec3 betaM = totalMie(lambda, K, turbidity) * mieCoefficient;',\n\n\t\t\t'// optical length',\n\t\t\t'// cutoff angle at 90 to avoid singularity in next formula.',\n\t\t\t'float zenithAngle = acos(max(0.0, dot(up, normalize(vWorldPosition - cameraPos))));',\n\t\t\t'float sR = rayleighZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));',\n\t\t\t'float sM = mieZenithLength / (cos(zenithAngle) + 0.15 * pow(93.885 - ((zenithAngle * 180.0) / pi), -1.253));',\n\n\n\n\t\t\t'// combined extinction factor\t',\n\t\t\t'vec3 Fex = exp(-(betaR * sR + betaM * sM));',\n\n\t\t\t'// in scattering',\n\t\t\t'float cosTheta = dot(normalize(vWorldPosition - cameraPos), sunDirection);',\n\n\t\t\t'float rPhase = rayleighPhase(cosTheta*0.5+0.5);',\n\t\t\t'vec3 betaRTheta = betaR * rPhase;',\n\n\t\t\t'float mPhase = hgPhase(cosTheta, mieDirectionalG);',\n\t\t\t'vec3 betaMTheta = betaM * mPhase;',\n\n\n\t\t\t'vec3 Lin = pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * (1.0 - Fex),vec3(1.5));',\n\t\t\t'Lin *= mix(vec3(1.0),pow(sunE * ((betaRTheta + betaMTheta) / (betaR + betaM)) * Fex,vec3(1.0/2.0)),clamp(pow(1.0-dot(up, sunDirection),5.0),0.0,1.0));',\n\n\t\t\t'//nightsky',\n\t\t\t'vec3 direction = normalize(vWorldPosition - cameraPos);',\n\t\t\t'float theta = acos(direction.y); // elevation --> y-axis, [-pi/2, pi/2]',\n\t\t\t'float phi = atan(direction.z, direction.x); // azimuth --> x-axis [-pi/2, pi/2]',\n\t\t\t'vec2 uv = vec2(phi, theta) / vec2(2.0*pi, pi) + vec2(0.5, 0.0);',\n\t\t\t'// vec3 L0 = texture2D(skySampler, uv).rgb+0.1 * Fex;',\n\t\t\t'vec3 L0 = vec3(0.1) * Fex;',\n\n\t\t\t'// composition + solar disc',\n\t\t\t'//if (cosTheta > sunAngularDiameterCos)',\n\t\t\t'float sundisk = smoothstep(sunAngularDiameterCos,sunAngularDiameterCos+0.00002,cosTheta);',\n\t\t\t'// if (normalize(vWorldPosition - cameraPos).y>0.0)',\n\t\t\t'L0 += (sunE * 19000.0 * Fex)*sundisk;',\n\n\n\t\t\t'vec3 whiteScale = 1.0/Uncharted2Tonemap(vec3(W));',\n\n\t\t\t'vec3 texColor = (Lin+L0); ',\n\t\t\t'texColor *= 0.04 ;',\n\t\t\t'texColor += vec3(0.0,0.001,0.0025)*0.3;',\n\n\t\t\t'float g_fMaxLuminance = 1.0;',\n\t\t\t'float fLumScaled = 0.1 / luminance; ',\n\t\t\t'float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (g_fMaxLuminance * g_fMaxLuminance)))) / (1.0 + fLumScaled); ',\n\n\t\t\t'float ExposureBias = fLumCompressed;',\n\n\t\t\t'vec3 curr = Uncharted2Tonemap((log2(2.0/pow(luminance,4.0)))*texColor);',\n\t\t\t'vec3 color = curr*whiteScale;',\n\n\t\t\t'vec3 retColor = pow(color,vec3(1.0/(1.2+(1.2*sunfade))));',\n\n\n\t\t\t'gl_FragColor.rgb = retColor;',\n\n\t\t\t'gl_FragColor.a = 1.0;',\n\t\t'}',\n\n\t].join( '\\n' )\n\n};\n\nvar Sky = function () {\n\n\tvar skyShader = THREE.ShaderLib[ 'sky' ];\n\tvar skyUniforms = THREE.UniformsUtils.clone( skyShader.uniforms );\n\n\tvar skyMat = new THREE.ShaderMaterial( {\n\t\tfragmentShader: skyShader.fragmentShader,\n\t\tvertexShader: skyShader.vertexShader,\n\t\tuniforms: skyUniforms,\n\t\tside: THREE.BackSide\n\t} );\n\n\tvar skyGeo = new THREE.SphereBufferGeometry( 450000, 32, 15 );\n\tvar skyMesh = new THREE.Mesh( skyGeo, skyMat );\n\n\n\t// Expose variables\n\tthis.mesh = skyMesh;\n\tthis.uniforms = skyUniforms;\n\n};\n\nexport default Sky;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/environment/Sky.js\n **/","/**\n * lodash 4.0.0 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\nvar debounce = require('lodash.debounce');\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide an options object to indicate whether\n * `func` should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n * on the trailing edge of the timeout only if the the throttled function is\n * invoked more than once during the `wait` timeout.\n *\n * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options] The options object.\n * @param {boolean} [options.leading=true] Specify invoking on the leading\n * edge of the timeout.\n * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n * edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // avoid excessively updating the position while scrolling\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // cancel a trailing throttled invocation\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n var leading = true,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n if (isObject(options)) {\n leading = 'leading' in options ? !!options.leading : leading;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n return debounce(func, wait, { 'leading': leading, 'maxWait': wait, 'trailing': trailing });\n}\n\n/**\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\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 // Avoid a V8 JIT bug in Chrome 19-20.\n // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\nmodule.exports = throttle;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lodash.throttle/index.js\n ** module id = 35\n ** module chunks = 0\n **/","/**\n * lodash 4.0.1 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\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 NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]';\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/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`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 * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @type Function\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => logs the number of milliseconds it took for the deferred function to be invoked\n */\nvar now = Date.now;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide an options object to indicate whether `func` should be invoked on\n * the leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent calls\n * to the debounced function return the result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n * on the trailing edge of the timeout only if the the debounced function is\n * invoked more than once during the `wait` timeout.\n *\n * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options] The options object.\n * @param {boolean} [options.leading=false] Specify invoking on the leading\n * edge of the timeout.\n * @param {number} [options.maxWait] The maximum time `func` is allowed to be\n * delayed before it's invoked.\n * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n * edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n var args,\n maxTimeoutId,\n result,\n stamp,\n thisArg,\n timeoutId,\n trailingCall,\n lastCalled = 0,\n leading = false,\n maxWait = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxWait = 'maxWait' in options && nativeMax(toNumber(options.maxWait) || 0, wait);\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function cancel() {\n if (timeoutId) {\n clearTimeout(timeoutId);\n }\n if (maxTimeoutId) {\n clearTimeout(maxTimeoutId);\n }\n lastCalled = 0;\n args = maxTimeoutId = thisArg = timeoutId = trailingCall = undefined;\n }\n\n function complete(isCalled, id) {\n if (id) {\n clearTimeout(id);\n }\n maxTimeoutId = timeoutId = trailingCall = undefined;\n if (isCalled) {\n lastCalled = now();\n result = func.apply(thisArg, args);\n if (!timeoutId && !maxTimeoutId) {\n args = thisArg = undefined;\n }\n }\n }\n\n function delayed() {\n var remaining = wait - (now() - stamp);\n if (remaining <= 0 || remaining > wait) {\n complete(trailingCall, maxTimeoutId);\n } else {\n timeoutId = setTimeout(delayed, remaining);\n }\n }\n\n function flush() {\n if ((timeoutId && trailingCall) || (maxTimeoutId && trailing)) {\n result = func.apply(thisArg, args);\n }\n cancel();\n return result;\n }\n\n function maxDelayed() {\n complete(trailing, timeoutId);\n }\n\n function debounced() {\n args = arguments;\n stamp = now();\n thisArg = this;\n trailingCall = trailing && (timeoutId || !leading);\n\n if (maxWait === false) {\n var leadingCall = leading && !timeoutId;\n } else {\n if (!maxTimeoutId && !leading) {\n lastCalled = stamp;\n }\n var remaining = maxWait - (stamp - lastCalled),\n isCalled = remaining <= 0 || remaining > maxWait;\n\n if (isCalled) {\n if (maxTimeoutId) {\n maxTimeoutId = clearTimeout(maxTimeoutId);\n }\n lastCalled = stamp;\n result = func.apply(thisArg, args);\n }\n else if (!maxTimeoutId) {\n maxTimeoutId = setTimeout(maxDelayed, remaining);\n }\n }\n if (isCalled && timeoutId) {\n timeoutId = clearTimeout(timeoutId);\n }\n else if (!timeoutId && wait !== maxWait) {\n timeoutId = setTimeout(delayed, wait);\n }\n if (leadingCall) {\n isCalled = true;\n result = func.apply(thisArg, args);\n }\n if (isCalled && !timeoutId && !maxTimeoutId) {\n args = thisArg = undefined;\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, 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 constructors, and\n // 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 [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\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 * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3);\n * // => 3\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3');\n * // => 3\n */\nfunction toNumber(value) {\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 = debounce;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lodash.throttle/~/lodash.debounce/index.js\n ** module id = 36\n ** module chunks = 0\n **/","import TileLayer from './TileLayer';\nimport ImageTile from './ImageTile';\nimport ImageTileLayerBaseMaterial from './ImageTileLayerBaseMaterial';\nimport throttle from 'lodash.throttle';\nimport THREE from 'three';\nimport extend from 'lodash.assign';\n\n// DONE: Find a way to avoid the flashing caused by the gap between old tiles\n// being removed and the new tiles being ready for display\n//\n// DONE: Simplest first step for MVP would be to give each tile mesh the colour\n// of the basemap ground so it blends in a little more, or have a huge ground\n// plane underneath all the tiles that shows through between tile updates.\n//\n// Could keep the old tiles around until the new ones are ready, though they'd\n// probably need to be layered in a way so the old tiles don't overlap new ones,\n// which is similar to how Leaflet approaches this (it has 2 layers)\n//\n// Could keep the tile from the previous quadtree level visible until all 4\n// tiles at the new / current level have finished loading and are displayed.\n// Perhaps by keeping a map of tiles by quadcode and a boolean for each of the\n// child quadcodes showing whether they are loaded and in view. If all true then\n// remove the parent tile, otherwise keep it on a lower layer.\n\n// TODO: Load and display a base layer separate to the LOD grid that is at a low\n// resolution – used as a backup / background to fill in empty areas / distance\n\n// DONE: Fix the issue where some tiles just don't load, or at least the texture\n// never shows up – tends to happen if you quickly zoom in / out past it while\n// it's still loading, leaving a blank space\n\n// TODO: Optimise the request of many image tiles – look at how Leaflet and\n// OpenWebGlobe approach this (eg. batching, queues, etc)\n\n// TODO: Cancel pending tile requests if they get removed from view before they\n// reach a ready state (eg. cancel image requests, etc). Need to ensure that the\n// images are re-requested when the tile is next in scene (even if from cache)\n\n// TODO: Consider not performing an LOD calculation on every frame, instead only\n// on move end so panning, orbiting and zooming stays smooth. Otherwise it's\n// possible for performance to tank if you pan, orbit or zoom rapidly while all\n// the LOD calculations are being made and new tiles requested.\n//\n// Pending tiles should continue to be requested and output to the scene on each\n// frame, but no new LOD calculations should be made.\n\nclass ImageTileLayer extends TileLayer {\n constructor(path, options) {\n var defaults = {\n distance: 40000\n };\n\n options = extend(defaults, options);\n\n super(options);\n\n this._path = path;\n }\n\n _onAdd(world) {\n super._onAdd(world);\n\n // Add base layer\n var geom = new THREE.PlaneBufferGeometry(200000, 200000, 1);\n\n var baseMaterial;\n if (this._world._environment._skybox) {\n baseMaterial = ImageTileLayerBaseMaterial('#f5f5f3', this._world._environment._skybox.getRenderTarget());\n } else {\n baseMaterial = ImageTileLayerBaseMaterial('#f5f5f3');\n }\n\n var mesh = new THREE.Mesh(geom, baseMaterial);\n mesh.rotation.x = -90 * Math.PI / 180;\n\n // TODO: It might be overkill to receive a shadow on the base layer as it's\n // rarely seen (good to have if performance difference is negligible)\n mesh.receiveShadow = true;\n\n this._baseLayer = mesh;\n this.add(mesh);\n\n // Trigger initial quadtree calculation on the next frame\n //\n // TODO: This is a hack to ensure the camera is all set up - a better\n // solution should be found\n setTimeout(() => {\n this._calculateLOD();\n this._initEvents();\n }, 0);\n }\n\n _initEvents() {\n // Run LOD calculations based on render calls\n //\n // Throttled to 1 LOD calculation per 100ms\n this._throttledWorldUpdate = throttle(this._onWorldUpdate, 100);\n\n this._world.on('preUpdate', this._throttledWorldUpdate, this);\n this._world.on('move', this._onWorldMove, this);\n }\n\n _onWorldUpdate() {\n this._calculateLOD();\n }\n\n _onWorldMove(latlon, point) {\n this._moveBaseLayer(point);\n }\n\n _moveBaseLayer(point) {\n this._baseLayer.position.x = point.x;\n this._baseLayer.position.z = point.y;\n }\n\n _createTile(quadcode, layer) {\n return ImageTile(quadcode, this._path, layer);\n }\n\n // Destroys the layer and removes it from the scene and memory\n destroy() {\n this._world.off('preUpdate', this._throttledWorldUpdate);\n this._world.off('move', this._onWorldMove);\n\n this._throttledWorldUpdate = null;\n\n // Dispose of mesh and materials\n this._baseLayer.geometry.dispose();\n this._baseLayer.geometry = null;\n\n if (this._baseLayer.material.map) {\n this._baseLayer.material.map.dispose();\n this._baseLayer.material.map = null;\n }\n\n this._baseLayer.material.dispose();\n this._baseLayer.material = null;\n\n this._baseLayer = null;\n\n // Run common destruction logic from parent\n super.destroy();\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(path, options) {\n return new ImageTileLayer(path, options);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/ImageTileLayer.js\n **/","import Layer from '../Layer';\nimport extend from 'lodash.assign';\nimport TileCache from './TileCache';\nimport THREE from 'three';\n\n// TODO: Consider keeping a single TileLayer / LOD instance running by default\n// that keeps a standard LOD grid for other layers to utilise, rather than\n// having to create their own, unique LOD grid and duplicate calculations when\n// they're going to use the same grid setup anyway\n//\n// It still makes sense to be able to have a custom LOD grid for some layers as\n// they may want to customise things, maybe not even using a quadtree at all!\n//\n// Perhaps it makes sense to split out the quadtree stuff into a singleton and\n// pass in the necessary parameters each time for the calculation step.\n//\n// Either way, it seems silly to force layers to have to create a new LOD grid\n// each time and create extra, duplicated processing every frame.\n\n// TODO: Allow passing in of options to define min/max LOD and a distance to use\n// for culling tiles beyond that distance.\n\n// DONE: Prevent tiles from being loaded if they are further than a certain\n// distance from the camera and are unlikely to be seen anyway\n\n// TODO: Avoid performing LOD calculation when it isn't required. For example,\n// when nothing has changed since the last frame and there are no tiles to be\n// loaded or in need of rendering\n\n// TODO: Only remove tiles from the layer that aren't to be rendered in the\n// current frame – it seems excessive to remove all tiles and re-add them on\n// every single frame, even if it's just array manipulation\n\n// TODO: Fix LOD calculation so min and max LOD can be changed without causing\n// problems (eg. making min above 5 causes all sorts of issues)\n\n// TODO: Reuse THREE objects where possible instead of creating new instances\n// on every LOD calculation\n\n// TODO: Consider not using THREE or LatLon / Point objects in LOD calculations\n// to avoid creating unnecessary memory for garbage collection\n\n// TODO: Prioritise loading of tiles at highest level in the quadtree (those\n// closest to the camera) so visual inconsistancies during loading are minimised\n\nclass TileLayer extends Layer {\n constructor(options) {\n super(options);\n\n var defaults = {\n maxCache: 1000,\n maxLOD: 18\n };\n\n this._options = extend(defaults, options);\n\n this._tileCache = TileCache(this._options.maxCache, tile => {\n this._destroyTile(tile);\n });\n\n // TODO: Work out why changing the minLOD causes loads of issues\n this._minLOD = 3;\n this._maxLOD = this._options.maxLOD;\n\n this._frustum = new THREE.Frustum();\n this._tiles = new THREE.Object3D();\n }\n\n _onAdd(world) {\n this.add(this._tiles);\n }\n\n _updateFrustum() {\n var camera = this._world.getCamera();\n var projScreenMatrix = new THREE.Matrix4();\n projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);\n\n this._frustum.setFromMatrix(camera.projectionMatrix);\n this._frustum.setFromMatrix(new THREE.Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse));\n }\n\n _tileInFrustum(tile) {\n var bounds = tile.getBounds();\n return this._frustum.intersectsBox(new THREE.Box3(new THREE.Vector3(bounds[0], 0, bounds[3]), new THREE.Vector3(bounds[2], 0, bounds[1])));\n }\n\n _calculateLOD() {\n if (this._stop || !this._world) {\n return;\n }\n\n // var start = performance.now();\n\n var camera = this._world.getCamera();\n\n // 1. Update and retrieve camera frustum\n this._updateFrustum(this._frustum, camera);\n\n // 2. Add the four root items of the quadtree to a check list\n var checkList = this._checklist;\n checkList = [];\n checkList.push(this._requestTile('0', this));\n checkList.push(this._requestTile('1', this));\n checkList.push(this._requestTile('2', this));\n checkList.push(this._requestTile('3', this));\n\n // 3. Call Divide, passing in the check list\n this._divide(checkList);\n\n // 4. Remove all tiles from layer\n this._removeTiles();\n\n // 5. Render the tiles remaining in the check list\n checkList.forEach((tile, index) => {\n // Skip tile if it's not in the current view frustum\n if (!this._tileInFrustum(tile)) {\n return;\n }\n\n if (this._options.distance && this._options.distance > 0) {\n // TODO: Can probably speed this up\n var center = tile.getCenter();\n var dist = (new THREE.Vector3(center[0], 0, center[1])).sub(camera.position).length();\n\n // Manual distance limit to cut down on tiles so far away\n if (dist > this._options.distance) {\n return;\n }\n }\n\n // Does the tile have a mesh?\n //\n // If yes, continue\n // If no, generate tile mesh, request texture and skip\n if (!tile.getMesh()) {\n tile.requestTileAsync();\n return;\n }\n\n // Are the mesh and texture ready?\n //\n // If yes, continue\n // If no, skip\n if (!tile.isReady()) {\n return;\n }\n\n // Add tile to layer (and to scene)\n this._tiles.add(tile.getMesh());\n });\n\n // console.log(performance.now() - start);\n }\n\n _divide(checkList) {\n var count = 0;\n var currentItem;\n var quadcode;\n\n // 1. Loop until count equals check list length\n while (count != checkList.length) {\n currentItem = checkList[count];\n quadcode = currentItem.getQuadcode();\n\n // 2. Increase count and continue loop if quadcode equals max LOD / zoom\n if (currentItem.length === this._maxLOD) {\n count++;\n continue;\n }\n\n // 3. Else, calculate screen-space error metric for quadcode\n if (this._screenSpaceError(currentItem)) {\n // 4. If error is sufficient...\n\n // 4a. Remove parent item from the check list\n checkList.splice(count, 1);\n\n // 4b. Add 4 child items to the check list\n checkList.push(this._requestTile(quadcode + '0', this));\n checkList.push(this._requestTile(quadcode + '1', this));\n checkList.push(this._requestTile(quadcode + '2', this));\n checkList.push(this._requestTile(quadcode + '3', this));\n\n // 4d. Continue the loop without increasing count\n continue;\n } else {\n // 5. Else, increase count and continue loop\n count++;\n }\n }\n }\n\n _screenSpaceError(tile) {\n var minDepth = this._minLOD;\n var maxDepth = this._maxLOD;\n\n var quadcode = tile.getQuadcode();\n\n var camera = this._world.getCamera();\n\n // Tweak this value to refine specific point that each quad is subdivided\n //\n // It's used to multiple the dimensions of the tile sides before\n // comparing against the tile distance from camera\n var quality = 3.0;\n\n // 1. Return false if quadcode length equals maxDepth (stop dividing)\n if (quadcode.length === maxDepth) {\n return false;\n }\n\n // 2. Return true if quadcode length is less than minDepth\n if (quadcode.length < minDepth) {\n return true;\n }\n\n // 3. Return false if quadcode bounds are not in view frustum\n if (!this._tileInFrustum(tile)) {\n return false;\n }\n\n var center = tile.getCenter();\n\n // 4. Calculate screen-space error metric\n // TODO: Use closest distance to one of the 4 tile corners\n var dist = (new THREE.Vector3(center[0], 0, center[1])).sub(camera.position).length();\n\n var error = quality * tile.getSide() / dist;\n\n // 5. Return true if error is greater than 1.0, else return false\n return (error > 1.0);\n }\n\n _removeTiles() {\n for (var i = this._tiles.children.length - 1; i >= 0; i--) {\n this._tiles.remove(this._tiles.children[i]);\n }\n }\n\n // Return a new tile instance\n _createTile(quadcode, layer) {}\n\n // Get a cached tile or request a new one if not in cache\n _requestTile(quadcode, layer) {\n var tile = this._tileCache.getTile(quadcode);\n\n if (!tile) {\n // Set up a brand new tile\n tile = this._createTile(quadcode, layer);\n\n // Add tile to cache, though it won't be ready yet as the data is being\n // requested from various places asynchronously\n this._tileCache.setTile(quadcode, tile);\n }\n\n return tile;\n }\n\n _destroyTile(tile) {\n // Remove tile from scene\n this._tiles.remove(tile.getMesh());\n\n // Delete any references to the tile within this component\n\n // Call destory on tile instance\n tile.destroy();\n }\n\n // Destroys the layer and removes it from the scene and memory\n destroy() {\n var i;\n\n // Remove all tiles\n for (i = this._tiles.children.length - 1; i >= 0; i--) {\n this._tiles.remove(this._tiles.children[i]);\n }\n\n this._tileCache.destroy();\n this._tileCache = null;\n\n this._tiles = null;\n this._frustum = null;\n\n super.destroy();\n }\n}\n\nexport default TileLayer;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/TileLayer.js\n **/","import LRUCache from 'lru-cache';\n\n// This process is based on a similar approach taken by OpenWebGlobe\n// See: https://github.com/OpenWebGlobe/WebViewer/blob/master/source/core/globecache.js\n\nclass TileCache {\n constructor(cacheLimit, onDestroyTile) {\n this._cache = LRUCache({\n max: cacheLimit,\n dispose: (key, tile) => {\n onDestroyTile(tile);\n }\n });\n }\n\n // Returns true if all specified tile providers are ready to be used\n // Otherwise, returns false\n isReady() {\n return false;\n }\n\n // Get a cached tile without requesting a new one\n getTile(quadcode) {\n return this._cache.get(quadcode);\n }\n\n // Add tile to cache\n setTile(quadcode, tile) {\n this._cache.set(quadcode, tile);\n }\n\n // Destroy the cache and remove it from memory\n //\n // TODO: Call destroy method on items in cache\n destroy() {\n this._cache.reset();\n this._cache = null;\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(cacheLimit, onDestroyTile) {\n return new TileCache(cacheLimit, onDestroyTile);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/TileCache.js\n **/","module.exports = LRUCache\n\n// This will be a proper iterable 'Map' in engines that support it,\n// or a fakey-fake PseudoMap in older versions.\nvar Map = require('pseudomap')\nvar util = require('util')\n\n// A linked list to keep track of recently-used-ness\nvar Yallist = require('yallist')\n\n// use symbols if possible, otherwise just _props\nvar symbols = {}\nvar hasSymbol = typeof Symbol === 'function'\nvar makeSymbol\nif (hasSymbol) {\n makeSymbol = function (key) {\n return Symbol.for(key)\n }\n} else {\n makeSymbol = function (key) {\n return '_' + key\n }\n}\n\nfunction priv (obj, key, val) {\n var sym\n if (symbols[key]) {\n sym = symbols[key]\n } else {\n sym = makeSymbol(key)\n symbols[key] = sym\n }\n if (arguments.length === 2) {\n return obj[sym]\n } else {\n obj[sym] = val\n return val\n }\n}\n\nfunction naiveLength () { return 1 }\n\n// lruList is a yallist where the head is the youngest\n// item, and the tail is the oldest. the list contains the Hit\n// objects as the entries.\n// Each Hit object has a reference to its Yallist.Node. This\n// never changes.\n//\n// cache is a Map (or PseudoMap) that matches the keys to\n// the Yallist.Node object.\nfunction LRUCache (options) {\n if (!(this instanceof LRUCache)) {\n return new LRUCache(options)\n }\n\n if (typeof options === 'number') {\n options = { max: options }\n }\n\n if (!options) {\n options = {}\n }\n\n var max = priv(this, 'max', options.max)\n // Kind of weird to have a default max of Infinity, but oh well.\n if (!max ||\n !(typeof max === 'number') ||\n max <= 0) {\n priv(this, 'max', Infinity)\n }\n\n var lc = options.length || naiveLength\n if (typeof lc !== 'function') {\n lc = naiveLength\n }\n priv(this, 'lengthCalculator', lc)\n\n priv(this, 'allowStale', options.stale || false)\n priv(this, 'maxAge', options.maxAge || 0)\n priv(this, 'dispose', options.dispose)\n this.reset()\n}\n\n// resize the cache when the max changes.\nObject.defineProperty(LRUCache.prototype, 'max', {\n set: function (mL) {\n if (!mL || !(typeof mL === 'number') || mL <= 0) {\n mL = Infinity\n }\n priv(this, 'max', mL)\n trim(this)\n },\n get: function () {\n return priv(this, 'max')\n },\n enumerable: true\n})\n\nObject.defineProperty(LRUCache.prototype, 'allowStale', {\n set: function (allowStale) {\n priv(this, 'allowStale', !!allowStale)\n },\n get: function () {\n return priv(this, 'allowStale')\n },\n enumerable: true\n})\n\nObject.defineProperty(LRUCache.prototype, 'maxAge', {\n set: function (mA) {\n if (!mA || !(typeof mA === 'number') || mA < 0) {\n mA = 0\n }\n priv(this, 'maxAge', mA)\n trim(this)\n },\n get: function () {\n return priv(this, 'maxAge')\n },\n enumerable: true\n})\n\n// resize the cache when the lengthCalculator changes.\nObject.defineProperty(LRUCache.prototype, 'lengthCalculator', {\n set: function (lC) {\n if (typeof lC !== 'function') {\n lC = naiveLength\n }\n if (lC !== priv(this, 'lengthCalculator')) {\n priv(this, 'lengthCalculator', lC)\n priv(this, 'length', 0)\n priv(this, 'lruList').forEach(function (hit) {\n hit.length = priv(this, 'lengthCalculator').call(this, hit.value, hit.key)\n priv(this, 'length', priv(this, 'length') + hit.length)\n }, this)\n }\n trim(this)\n },\n get: function () { return priv(this, 'lengthCalculator') },\n enumerable: true\n})\n\nObject.defineProperty(LRUCache.prototype, 'length', {\n get: function () { return priv(this, 'length') },\n enumerable: true\n})\n\nObject.defineProperty(LRUCache.prototype, 'itemCount', {\n get: function () { return priv(this, 'lruList').length },\n enumerable: true\n})\n\nLRUCache.prototype.rforEach = function (fn, thisp) {\n thisp = thisp || this\n for (var walker = priv(this, 'lruList').tail; walker !== null;) {\n var prev = walker.prev\n forEachStep(this, fn, walker, thisp)\n walker = prev\n }\n}\n\nfunction forEachStep (self, fn, node, thisp) {\n var hit = node.value\n if (isStale(self, hit)) {\n del(self, node)\n if (!priv(self, 'allowStale')) {\n hit = undefined\n }\n }\n if (hit) {\n fn.call(thisp, hit.value, hit.key, self)\n }\n}\n\nLRUCache.prototype.forEach = function (fn, thisp) {\n thisp = thisp || this\n for (var walker = priv(this, 'lruList').head; walker !== null;) {\n var next = walker.next\n forEachStep(this, fn, walker, thisp)\n walker = next\n }\n}\n\nLRUCache.prototype.keys = function () {\n return priv(this, 'lruList').toArray().map(function (k) {\n return k.key\n }, this)\n}\n\nLRUCache.prototype.values = function () {\n return priv(this, 'lruList').toArray().map(function (k) {\n return k.value\n }, this)\n}\n\nLRUCache.prototype.reset = function () {\n if (priv(this, 'dispose') &&\n priv(this, 'lruList') &&\n priv(this, 'lruList').length) {\n priv(this, 'lruList').forEach(function (hit) {\n priv(this, 'dispose').call(this, hit.key, hit.value)\n }, this)\n }\n\n priv(this, 'cache', new Map()) // hash of items by key\n priv(this, 'lruList', new Yallist()) // list of items in order of use recency\n priv(this, 'length', 0) // length of items in the list\n}\n\nLRUCache.prototype.dump = function () {\n return priv(this, 'lruList').map(function (hit) {\n if (!isStale(this, hit)) {\n return {\n k: hit.key,\n v: hit.value,\n e: hit.now + (hit.maxAge || 0)\n }\n }\n }, this).toArray().filter(function (h) {\n return h\n })\n}\n\nLRUCache.prototype.dumpLru = function () {\n return priv(this, 'lruList')\n}\n\nLRUCache.prototype.inspect = function (n, opts) {\n var str = 'LRUCache {'\n var extras = false\n\n var as = priv(this, 'allowStale')\n if (as) {\n str += '\\n allowStale: true'\n extras = true\n }\n\n var max = priv(this, 'max')\n if (max && max !== Infinity) {\n if (extras) {\n str += ','\n }\n str += '\\n max: ' + util.inspect(max, opts)\n extras = true\n }\n\n var maxAge = priv(this, 'maxAge')\n if (maxAge) {\n if (extras) {\n str += ','\n }\n str += '\\n maxAge: ' + util.inspect(maxAge, opts)\n extras = true\n }\n\n var lc = priv(this, 'lengthCalculator')\n if (lc && lc !== naiveLength) {\n if (extras) {\n str += ','\n }\n str += '\\n length: ' + util.inspect(priv(this, 'length'), opts)\n extras = true\n }\n\n var didFirst = false\n priv(this, 'lruList').forEach(function (item) {\n if (didFirst) {\n str += ',\\n '\n } else {\n if (extras) {\n str += ',\\n'\n }\n didFirst = true\n str += '\\n '\n }\n var key = util.inspect(item.key).split('\\n').join('\\n ')\n var val = { value: item.value }\n if (item.maxAge !== maxAge) {\n val.maxAge = item.maxAge\n }\n if (lc !== naiveLength) {\n val.length = item.length\n }\n if (isStale(this, item)) {\n val.stale = true\n }\n\n val = util.inspect(val, opts).split('\\n').join('\\n ')\n str += key + ' => ' + val\n })\n\n if (didFirst || extras) {\n str += '\\n'\n }\n str += '}'\n\n return str\n}\n\nLRUCache.prototype.set = function (key, value, maxAge) {\n maxAge = maxAge || priv(this, 'maxAge')\n\n var now = maxAge ? Date.now() : 0\n var len = priv(this, 'lengthCalculator').call(this, value, key)\n\n if (priv(this, 'cache').has(key)) {\n if (len > priv(this, 'max')) {\n del(this, priv(this, 'cache').get(key))\n return false\n }\n\n var node = priv(this, 'cache').get(key)\n var item = node.value\n\n // dispose of the old one before overwriting\n if (priv(this, 'dispose')) {\n priv(this, 'dispose').call(this, key, item.value)\n }\n\n item.now = now\n item.maxAge = maxAge\n item.value = value\n priv(this, 'length', priv(this, 'length') + (len - item.length))\n item.length = len\n this.get(key)\n trim(this)\n return true\n }\n\n var hit = new Entry(key, value, len, now, maxAge)\n\n // oversized objects fall out of cache automatically.\n if (hit.length > priv(this, 'max')) {\n if (priv(this, 'dispose')) {\n priv(this, 'dispose').call(this, key, value)\n }\n return false\n }\n\n priv(this, 'length', priv(this, 'length') + hit.length)\n priv(this, 'lruList').unshift(hit)\n priv(this, 'cache').set(key, priv(this, 'lruList').head)\n trim(this)\n return true\n}\n\nLRUCache.prototype.has = function (key) {\n if (!priv(this, 'cache').has(key)) return false\n var hit = priv(this, 'cache').get(key).value\n if (isStale(this, hit)) {\n return false\n }\n return true\n}\n\nLRUCache.prototype.get = function (key) {\n return get(this, key, true)\n}\n\nLRUCache.prototype.peek = function (key) {\n return get(this, key, false)\n}\n\nLRUCache.prototype.pop = function () {\n var node = priv(this, 'lruList').tail\n if (!node) return null\n del(this, node)\n return node.value\n}\n\nLRUCache.prototype.del = function (key) {\n del(this, priv(this, 'cache').get(key))\n}\n\nLRUCache.prototype.load = function (arr) {\n // reset the cache\n this.reset()\n\n var now = Date.now()\n // A previous serialized cache has the most recent items first\n for (var l = arr.length - 1; l >= 0; l--) {\n var hit = arr[l]\n var expiresAt = hit.e || 0\n if (expiresAt === 0) {\n // the item was created without expiration in a non aged cache\n this.set(hit.k, hit.v)\n } else {\n var maxAge = expiresAt - now\n // dont add already expired items\n if (maxAge > 0) {\n this.set(hit.k, hit.v, maxAge)\n }\n }\n }\n}\n\nLRUCache.prototype.prune = function () {\n var self = this\n priv(this, 'cache').forEach(function (value, key) {\n get(self, key, false)\n })\n}\n\nfunction get (self, key, doUse) {\n var node = priv(self, 'cache').get(key)\n if (node) {\n var hit = node.value\n if (isStale(self, hit)) {\n del(self, node)\n if (!priv(self, 'allowStale')) hit = undefined\n } else {\n if (doUse) {\n priv(self, 'lruList').unshiftNode(node)\n }\n }\n if (hit) hit = hit.value\n }\n return hit\n}\n\nfunction isStale (self, hit) {\n if (!hit || (!hit.maxAge && !priv(self, 'maxAge'))) {\n return false\n }\n var stale = false\n var diff = Date.now() - hit.now\n if (hit.maxAge) {\n stale = diff > hit.maxAge\n } else {\n stale = priv(self, 'maxAge') && (diff > priv(self, 'maxAge'))\n }\n return stale\n}\n\nfunction trim (self) {\n if (priv(self, 'length') > priv(self, 'max')) {\n for (var walker = priv(self, 'lruList').tail;\n priv(self, 'length') > priv(self, 'max') && walker !== null;) {\n // We know that we're about to delete this one, and also\n // what the next least recently used key will be, so just\n // go ahead and set it now.\n var prev = walker.prev\n del(self, walker)\n walker = prev\n }\n }\n}\n\nfunction del (self, node) {\n if (node) {\n var hit = node.value\n if (priv(self, 'dispose')) {\n priv(self, 'dispose').call(this, hit.key, hit.value)\n }\n priv(self, 'length', priv(self, 'length') - hit.length)\n priv(self, 'cache').delete(hit.key)\n priv(self, 'lruList').removeNode(node)\n }\n}\n\n// classy, since V8 prefers predictable objects.\nfunction Entry (key, value, length, now, maxAge) {\n this.key = key\n this.value = value\n this.length = length\n this.now = now\n this.maxAge = maxAge || 0\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/lru-cache/lib/lru-cache.js\n ** module id = 40\n ** module chunks = 0\n **/","if (process.env.npm_package_name === 'pseudomap' &&\n process.env.npm_lifecycle_script === 'test')\n process.env.TEST_PSEUDOMAP = 'true'\n\nif (typeof Map === 'function' && !process.env.TEST_PSEUDOMAP) {\n module.exports = Map\n} else {\n module.exports = require('./pseudomap')\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/pseudomap/map.js\n ** module id = 41\n ** module chunks = 0\n **/","// shim for using process in browser\n\nvar process = module.exports = {};\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = setTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n clearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n setTimeout(drainQueue, 0);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/process/browser.js\n ** module id = 42\n ** module chunks = 0\n **/","var hasOwnProperty = Object.prototype.hasOwnProperty\n\nmodule.exports = PseudoMap\n\nfunction PseudoMap (set) {\n if (!(this instanceof PseudoMap)) // whyyyyyyy\n throw new TypeError(\"Constructor PseudoMap requires 'new'\")\n\n this.clear()\n\n if (set) {\n if ((set instanceof PseudoMap) ||\n (typeof Map === 'function' && set instanceof Map))\n set.forEach(function (value, key) {\n this.set(key, value)\n }, this)\n else if (Array.isArray(set))\n set.forEach(function (kv) {\n this.set(kv[0], kv[1])\n }, this)\n else\n throw new TypeError('invalid argument')\n }\n}\n\nPseudoMap.prototype.forEach = function (fn, thisp) {\n thisp = thisp || this\n Object.keys(this._data).forEach(function (k) {\n if (k !== 'size')\n fn.call(thisp, this._data[k].value, this._data[k].key)\n }, this)\n}\n\nPseudoMap.prototype.has = function (k) {\n return !!find(this._data, k)\n}\n\nPseudoMap.prototype.get = function (k) {\n var res = find(this._data, k)\n return res && res.value\n}\n\nPseudoMap.prototype.set = function (k, v) {\n set(this._data, k, v)\n}\n\nPseudoMap.prototype.delete = function (k) {\n var res = find(this._data, k)\n if (res) {\n delete this._data[res._index]\n this._data.size--\n }\n}\n\nPseudoMap.prototype.clear = function () {\n var data = Object.create(null)\n data.size = 0\n\n Object.defineProperty(this, '_data', {\n value: data,\n enumerable: false,\n configurable: true,\n writable: false\n })\n}\n\nObject.defineProperty(PseudoMap.prototype, 'size', {\n get: function () {\n return this._data.size\n },\n set: function (n) {},\n enumerable: true,\n configurable: true\n})\n\nPseudoMap.prototype.values =\nPseudoMap.prototype.keys =\nPseudoMap.prototype.entries = function () {\n throw new Error('iterators are not implemented in this version')\n}\n\n// Either identical, or both NaN\nfunction same (a, b) {\n return a === b || a !== a && b !== b\n}\n\nfunction Entry (k, v, i) {\n this.key = k\n this.value = v\n this._index = i\n}\n\nfunction find (data, k) {\n for (var i = 0, s = '_' + k, key = s;\n hasOwnProperty.call(data, key);\n key = s + i++) {\n if (same(data[key].key, k))\n return data[key]\n }\n}\n\nfunction set (data, k, v) {\n for (var i = 0, s = '_' + k, key = s;\n hasOwnProperty.call(data, key);\n key = s + i++) {\n if (same(data[key].key, k)) {\n data[key].value = v\n return\n }\n }\n data.size++\n data[key] = new Entry(k, v, key)\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/pseudomap/pseudomap.js\n ** module id = 43\n ** module chunks = 0\n **/","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n if (!isString(f)) {\n var objects = [];\n for (var i = 0; i < arguments.length; i++) {\n objects.push(inspect(arguments[i]));\n }\n return objects.join(' ');\n }\n\n var i = 1;\n var args = arguments;\n var len = args.length;\n var str = String(f).replace(formatRegExp, function(x) {\n if (x === '%%') return '%';\n if (i >= len) return x;\n switch (x) {\n case '%s': return String(args[i++]);\n case '%d': return Number(args[i++]);\n case '%j':\n try {\n return JSON.stringify(args[i++]);\n } catch (_) {\n return '[Circular]';\n }\n default:\n return x;\n }\n });\n for (var x = args[i]; i < len; x = args[++i]) {\n if (isNull(x) || !isObject(x)) {\n str += ' ' + x;\n } else {\n str += ' ' + inspect(x);\n }\n }\n return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n // Allow for deprecating things in the process of starting up.\n if (isUndefined(global.process)) {\n return function() {\n return exports.deprecate(fn, msg).apply(this, arguments);\n };\n }\n\n if (process.noDeprecation === true) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (process.throwDeprecation) {\n throw new Error(msg);\n } else if (process.traceDeprecation) {\n console.trace(msg);\n } else {\n console.error(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n if (isUndefined(debugEnviron))\n debugEnviron = process.env.NODE_DEBUG || '';\n set = set.toUpperCase();\n if (!debugs[set]) {\n if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n var pid = process.pid;\n debugs[set] = function() {\n var msg = exports.format.apply(exports, arguments);\n console.error('%s %d: %s', set, pid, msg);\n };\n } else {\n debugs[set] = function() {};\n }\n }\n return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n // default options\n var ctx = {\n seen: [],\n stylize: stylizeNoColor\n };\n // legacy...\n if (arguments.length >= 3) ctx.depth = arguments[2];\n if (arguments.length >= 4) ctx.colors = arguments[3];\n if (isBoolean(opts)) {\n // legacy...\n ctx.showHidden = opts;\n } else if (opts) {\n // got an \"options\" object\n exports._extend(ctx, opts);\n }\n // set default options\n if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n if (isUndefined(ctx.depth)) ctx.depth = 2;\n if (isUndefined(ctx.colors)) ctx.colors = false;\n if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n if (ctx.colors) ctx.stylize = stylizeWithColor;\n return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n 'bold' : [1, 22],\n 'italic' : [3, 23],\n 'underline' : [4, 24],\n 'inverse' : [7, 27],\n 'white' : [37, 39],\n 'grey' : [90, 39],\n 'black' : [30, 39],\n 'blue' : [34, 39],\n 'cyan' : [36, 39],\n 'green' : [32, 39],\n 'magenta' : [35, 39],\n 'red' : [31, 39],\n 'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n 'special': 'cyan',\n 'number': 'yellow',\n 'boolean': 'yellow',\n 'undefined': 'grey',\n 'null': 'bold',\n 'string': 'green',\n 'date': 'magenta',\n // \"name\": intentionally not styling\n 'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n var style = inspect.styles[styleType];\n\n if (style) {\n return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n '\\u001b[' + inspect.colors[style][1] + 'm';\n } else {\n return str;\n }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n return str;\n}\n\n\nfunction arrayToHash(array) {\n var hash = {};\n\n array.forEach(function(val, idx) {\n hash[val] = true;\n });\n\n return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n // Provide a hook for user-specified inspect functions.\n // Check that value is an object with an inspect function on it\n if (ctx.customInspect &&\n value &&\n isFunction(value.inspect) &&\n // Filter out the util module, it's inspect function is special\n value.inspect !== exports.inspect &&\n // Also filter out any prototype objects using the circular check.\n !(value.constructor && value.constructor.prototype === value)) {\n var ret = value.inspect(recurseTimes, ctx);\n if (!isString(ret)) {\n ret = formatValue(ctx, ret, recurseTimes);\n }\n return ret;\n }\n\n // Primitive types cannot have properties\n var primitive = formatPrimitive(ctx, value);\n if (primitive) {\n return primitive;\n }\n\n // Look up the keys of the object.\n var keys = Object.keys(value);\n var visibleKeys = arrayToHash(keys);\n\n if (ctx.showHidden) {\n keys = Object.getOwnPropertyNames(value);\n }\n\n // IE doesn't make error fields non-enumerable\n // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n if (isError(value)\n && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n return formatError(value);\n }\n\n // Some type of object without properties can be shortcutted.\n if (keys.length === 0) {\n if (isFunction(value)) {\n var name = value.name ? ': ' + value.name : '';\n return ctx.stylize('[Function' + name + ']', 'special');\n }\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n }\n if (isDate(value)) {\n return ctx.stylize(Date.prototype.toString.call(value), 'date');\n }\n if (isError(value)) {\n return formatError(value);\n }\n }\n\n var base = '', array = false, braces = ['{', '}'];\n\n // Make Array say that they are Array\n if (isArray(value)) {\n array = true;\n braces = ['[', ']'];\n }\n\n // Make functions say that they are functions\n if (isFunction(value)) {\n var n = value.name ? ': ' + value.name : '';\n base = ' [Function' + n + ']';\n }\n\n // Make RegExps say that they are RegExps\n if (isRegExp(value)) {\n base = ' ' + RegExp.prototype.toString.call(value);\n }\n\n // Make dates with properties first say the date\n if (isDate(value)) {\n base = ' ' + Date.prototype.toUTCString.call(value);\n }\n\n // Make error with message first say the error\n if (isError(value)) {\n base = ' ' + formatError(value);\n }\n\n if (keys.length === 0 && (!array || value.length == 0)) {\n return braces[0] + base + braces[1];\n }\n\n if (recurseTimes < 0) {\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n } else {\n return ctx.stylize('[Object]', 'special');\n }\n }\n\n ctx.seen.push(value);\n\n var output;\n if (array) {\n output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n } else {\n output = keys.map(function(key) {\n return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n });\n }\n\n ctx.seen.pop();\n\n return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n if (isUndefined(value))\n return ctx.stylize('undefined', 'undefined');\n if (isString(value)) {\n var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n .replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"') + '\\'';\n return ctx.stylize(simple, 'string');\n }\n if (isNumber(value))\n return ctx.stylize('' + value, 'number');\n if (isBoolean(value))\n return ctx.stylize('' + value, 'boolean');\n // For some reason typeof null is \"object\", so special case here.\n if (isNull(value))\n return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n var output = [];\n for (var i = 0, l = value.length; i < l; ++i) {\n if (hasOwnProperty(value, String(i))) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n String(i), true));\n } else {\n output.push('');\n }\n }\n keys.forEach(function(key) {\n if (!key.match(/^\\d+$/)) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n key, true));\n }\n });\n return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n var name, str, desc;\n desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n if (desc.get) {\n if (desc.set) {\n str = ctx.stylize('[Getter/Setter]', 'special');\n } else {\n str = ctx.stylize('[Getter]', 'special');\n }\n } else {\n if (desc.set) {\n str = ctx.stylize('[Setter]', 'special');\n }\n }\n if (!hasOwnProperty(visibleKeys, key)) {\n name = '[' + key + ']';\n }\n if (!str) {\n if (ctx.seen.indexOf(desc.value) < 0) {\n if (isNull(recurseTimes)) {\n str = formatValue(ctx, desc.value, null);\n } else {\n str = formatValue(ctx, desc.value, recurseTimes - 1);\n }\n if (str.indexOf('\\n') > -1) {\n if (array) {\n str = str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n').substr(2);\n } else {\n str = '\\n' + str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n');\n }\n }\n } else {\n str = ctx.stylize('[Circular]', 'special');\n }\n }\n if (isUndefined(name)) {\n if (array && key.match(/^\\d+$/)) {\n return str;\n }\n name = JSON.stringify('' + key);\n if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n name = name.substr(1, name.length - 2);\n name = ctx.stylize(name, 'name');\n } else {\n name = name.replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"')\n .replace(/(^\"|\"$)/g, \"'\");\n name = ctx.stylize(name, 'string');\n }\n }\n\n return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n var numLinesEst = 0;\n var length = output.reduce(function(prev, cur) {\n numLinesEst++;\n if (cur.indexOf('\\n') >= 0) numLinesEst++;\n return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n }, 0);\n\n if (length > 60) {\n return braces[0] +\n (base === '' ? '' : base + '\\n ') +\n ' ' +\n output.join(',\\n ') +\n ' ' +\n braces[1];\n }\n\n return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n return isObject(e) &&\n (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n var d = new Date();\n var time = [pad(d.getHours()),\n pad(d.getMinutes()),\n pad(d.getSeconds())].join(':');\n return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n // Don't do anything if add isn't an object\n if (!add || !isObject(add)) return origin;\n\n var keys = Object.keys(add);\n var i = keys.length;\n while (i--) {\n origin[keys[i]] = add[keys[i]];\n }\n return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/util/util.js\n ** module id = 44\n ** module chunks = 0\n **/","module.exports = function isBuffer(arg) {\n return arg && typeof arg === 'object'\n && typeof arg.copy === 'function'\n && typeof arg.fill === 'function'\n && typeof arg.readUInt8 === 'function';\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/util/support/isBufferBrowser.js\n ** module id = 45\n ** module chunks = 0\n **/","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/inherits/inherits_browser.js\n ** module id = 46\n ** module chunks = 0\n **/","module.exports = Yallist\n\nYallist.Node = Node\nYallist.create = Yallist\n\nfunction Yallist (list) {\n var self = this\n if (!(self instanceof Yallist)) {\n self = new Yallist()\n }\n\n self.tail = null\n self.head = null\n self.length = 0\n\n if (list && typeof list.forEach === 'function') {\n list.forEach(function (item) {\n self.push(item)\n })\n } else if (arguments.length > 0) {\n for (var i = 0, l = arguments.length; i < l; i++) {\n self.push(arguments[i])\n }\n }\n\n return self\n}\n\nYallist.prototype.removeNode = function (node) {\n if (node.list !== this) {\n throw new Error('removing node which does not belong to this list')\n }\n\n var next = node.next\n var prev = node.prev\n\n if (next) {\n next.prev = prev\n }\n\n if (prev) {\n prev.next = next\n }\n\n if (node === this.head) {\n this.head = next\n }\n if (node === this.tail) {\n this.tail = prev\n }\n\n node.list.length --\n node.next = null\n node.prev = null\n node.list = null\n}\n\nYallist.prototype.unshiftNode = function (node) {\n if (node === this.head) {\n return\n }\n\n if (node.list) {\n node.list.removeNode(node)\n }\n\n var head = this.head\n node.list = this\n node.next = head\n if (head) {\n head.prev = node\n }\n\n this.head = node\n if (!this.tail) {\n this.tail = node\n }\n this.length ++\n}\n\nYallist.prototype.pushNode = function (node) {\n if (node === this.tail) {\n return\n }\n\n if (node.list) {\n node.list.removeNode(node)\n }\n\n var tail = this.tail\n node.list = this\n node.prev = tail\n if (tail) {\n tail.next = node\n }\n\n this.tail = node\n if (!this.head) {\n this.head = node\n }\n this.length ++\n}\n\nYallist.prototype.push = function () {\n for (var i = 0, l = arguments.length; i < l; i++) {\n push(this, arguments[i])\n }\n return this.length\n}\n\nYallist.prototype.unshift = function () {\n for (var i = 0, l = arguments.length; i < l; i++) {\n unshift(this, arguments[i])\n }\n return this.length\n}\n\nYallist.prototype.pop = function () {\n if (!this.tail)\n return undefined\n\n var res = this.tail.value\n this.tail = this.tail.prev\n this.tail.next = null\n this.length --\n return res\n}\n\nYallist.prototype.shift = function () {\n if (!this.head)\n return undefined\n\n var res = this.head.value\n this.head = this.head.next\n this.head.prev = null\n this.length --\n return res\n}\n\nYallist.prototype.forEach = function (fn, thisp) {\n thisp = thisp || this\n for (var walker = this.head, i = 0; walker !== null; i++) {\n fn.call(thisp, walker.value, i, this)\n walker = walker.next\n }\n}\n\nYallist.prototype.forEachReverse = function (fn, thisp) {\n thisp = thisp || this\n for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {\n fn.call(thisp, walker.value, i, this)\n walker = walker.prev\n }\n}\n\nYallist.prototype.get = function (n) {\n for (var i = 0, walker = this.head; walker !== null && i < n; i++) {\n // abort out of the list early if we hit a cycle\n walker = walker.next\n }\n if (i === n && walker !== null) {\n return walker.value\n }\n}\n\nYallist.prototype.getReverse = function (n) {\n for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {\n // abort out of the list early if we hit a cycle\n walker = walker.prev\n }\n if (i === n && walker !== null) {\n return walker.value\n }\n}\n\nYallist.prototype.map = function (fn, thisp) {\n thisp = thisp || this\n var res = new Yallist()\n for (var walker = this.head; walker !== null; ) {\n res.push(fn.call(thisp, walker.value, this))\n walker = walker.next\n }\n return res\n}\n\nYallist.prototype.mapReverse = function (fn, thisp) {\n thisp = thisp || this\n var res = new Yallist()\n for (var walker = this.tail; walker !== null;) {\n res.push(fn.call(thisp, walker.value, this))\n walker = walker.prev\n }\n return res\n}\n\nYallist.prototype.reduce = function (fn, initial) {\n var acc\n var walker = this.head\n if (arguments.length > 1) {\n acc = initial\n } else if (this.head) {\n walker = this.head.next\n acc = this.head.value\n } else {\n throw new TypeError('Reduce of empty list with no initial value')\n }\n\n for (var i = 0; walker !== null; i++) {\n acc = fn(acc, walker.value, i)\n walker = walker.next\n }\n\n return acc\n}\n\nYallist.prototype.reduceReverse = function (fn, initial) {\n var acc\n var walker = this.tail\n if (arguments.length > 1) {\n acc = initial\n } else if (this.tail) {\n walker = this.tail.prev\n acc = this.tail.value\n } else {\n throw new TypeError('Reduce of empty list with no initial value')\n }\n\n for (var i = this.length - 1; walker !== null; i--) {\n acc = fn(acc, walker.value, i)\n walker = walker.prev\n }\n\n return acc\n}\n\nYallist.prototype.toArray = function () {\n var arr = new Array(this.length)\n for (var i = 0, walker = this.head; walker !== null; i++) {\n arr[i] = walker.value\n walker = walker.next\n }\n return arr\n}\n\nYallist.prototype.toArrayReverse = function () {\n var arr = new Array(this.length)\n for (var i = 0, walker = this.tail; walker !== null; i++) {\n arr[i] = walker.value\n walker = walker.prev\n }\n return arr\n}\n\nYallist.prototype.slice = function (from, to) {\n to = to || this.length\n if (to < 0) {\n to += this.length\n }\n from = from || 0\n if (from < 0) {\n from += this.length\n }\n var ret = new Yallist()\n if (to < from || to < 0) {\n return ret\n }\n if (from < 0) {\n from = 0\n }\n if (to > this.length) {\n to = this.length\n }\n for (var i = 0, walker = this.head; walker !== null && i < from; i++) {\n walker = walker.next\n }\n for (; walker !== null && i < to; i++, walker = walker.next) {\n ret.push(walker.value)\n }\n return ret\n}\n\nYallist.prototype.sliceReverse = function (from, to) {\n to = to || this.length\n if (to < 0) {\n to += this.length\n }\n from = from || 0\n if (from < 0) {\n from += this.length\n }\n var ret = new Yallist()\n if (to < from || to < 0) {\n return ret\n }\n if (from < 0) {\n from = 0\n }\n if (to > this.length) {\n to = this.length\n }\n for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {\n walker = walker.prev\n }\n for (; walker !== null && i > from; i--, walker = walker.prev) {\n ret.push(walker.value)\n }\n return ret\n}\n\nYallist.prototype.reverse = function () {\n var head = this.head\n var tail = this.tail\n for (var walker = head; walker !== null; walker = walker.prev) {\n var p = walker.prev\n walker.prev = walker.next\n walker.next = p\n }\n this.head = tail\n this.tail = head\n return this\n}\n\nfunction push (self, item) {\n self.tail = new Node(item, self.tail, null, self)\n if (!self.head) {\n self.head = self.tail\n }\n self.length ++\n}\n\nfunction unshift (self, item) {\n self.head = new Node(item, null, self.head, self)\n if (!self.tail) {\n self.tail = self.head\n }\n self.length ++\n}\n\nfunction Node (value, prev, next, list) {\n if (!(this instanceof Node)) {\n return new Node(value, prev, next, list)\n }\n\n this.list = list\n this.value = value\n\n if (prev) {\n prev.next = this\n this.prev = prev\n } else {\n this.prev = null\n }\n\n if (next) {\n next.prev = this\n this.next = next\n } else {\n this.next = null\n }\n}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/yallist/yallist.js\n ** module id = 47\n ** module chunks = 0\n **/","import Tile from './Tile';\nimport BoxHelper from '../../vendor/BoxHelper';\nimport THREE from 'three';\n\nclass ImageTile extends Tile {\n constructor(quadcode, path, layer) {\n super(quadcode, path, layer);\n }\n\n // Request data for the tile\n requestTileAsync() {\n // Making this asynchronous really speeds up the LOD framerate\n setTimeout(() => {\n if (!this._mesh) {\n this._mesh = this._createMesh();\n this._requestTile();\n }\n }, 0);\n }\n\n destroy() {\n // Cancel any pending requests\n this._abortRequest();\n\n // Clear image reference\n this._image = null;\n\n super.destroy();\n }\n\n _createMesh() {\n // Something went wrong and the tile\n //\n // Possibly removed by the cache before loaded\n if (!this._center) {\n return;\n }\n\n var mesh = new THREE.Object3D();\n var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n\n var material;\n if (!this._world._environment._skybox) {\n material = new THREE.MeshBasicMaterial({\n depthWrite: false\n });\n\n // var material = new THREE.MeshPhongMaterial({\n // depthWrite: false\n // });\n } else {\n // Other MeshStandardMaterial settings\n //\n // material.envMapIntensity will change the amount of colour reflected(?)\n // from the environment map – can be greater than 1 for more intensity\n\n material = new THREE.MeshStandardMaterial({\n depthWrite: false\n });\n material.roughness = 1;\n material.metalness = 0.1;\n material.envMap = this._world._environment._skybox.getRenderTarget();\n }\n\n var localMesh = new THREE.Mesh(geom, material);\n localMesh.rotation.x = -90 * Math.PI / 180;\n\n localMesh.receiveShadow = true;\n\n mesh.add(localMesh);\n mesh.renderOrder = 0;\n\n mesh.position.x = this._center[0];\n mesh.position.z = this._center[1];\n\n // var box = new BoxHelper(localMesh);\n // mesh.add(box);\n //\n // mesh.add(this._createDebugMesh());\n\n return mesh;\n }\n\n _createDebugMesh() {\n var canvas = document.createElement('canvas');\n canvas.width = 256;\n canvas.height = 256;\n\n var context = canvas.getContext('2d');\n context.font = 'Bold 20px Helvetica Neue, Verdana, Arial';\n context.fillStyle = '#ff0000';\n context.fillText(this._quadcode, 20, canvas.width / 2 - 5);\n context.fillText(this._tile.toString(), 20, canvas.width / 2 + 25);\n\n var texture = new THREE.Texture(canvas);\n\n // Silky smooth images when tilted\n texture.magFilter = THREE.LinearFilter;\n texture.minFilter = THREE.LinearMipMapLinearFilter;\n\n // TODO: Set this to renderer.getMaxAnisotropy() / 4\n texture.anisotropy = 4;\n\n texture.needsUpdate = true;\n\n var material = new THREE.MeshBasicMaterial({\n map: texture,\n transparent: true,\n depthWrite: false\n });\n\n var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n var mesh = new THREE.Mesh(geom, material);\n\n mesh.rotation.x = -90 * Math.PI / 180;\n mesh.position.y = 0.1;\n\n return mesh;\n }\n\n _requestTile() {\n var urlParams = {\n x: this._tile[0],\n y: this._tile[1],\n z: this._tile[2]\n };\n\n var url = this._getTileURL(urlParams);\n\n var image = document.createElement('img');\n\n image.addEventListener('load', event => {\n var texture = new THREE.Texture();\n\n texture.image = image;\n texture.needsUpdate = true;\n\n // Silky smooth images when tilted\n texture.magFilter = THREE.LinearFilter;\n texture.minFilter = THREE.LinearMipMapLinearFilter;\n\n // TODO: Set this to renderer.getMaxAnisotropy() / 4\n texture.anisotropy = 4;\n\n texture.needsUpdate = true;\n\n // Something went wrong and the tile or its material is missing\n //\n // Possibly removed by the cache before the image loaded\n if (!this._mesh || !this._mesh.children[0] || !this._mesh.children[0].material) {\n return;\n }\n\n this._mesh.children[0].material.map = texture;\n this._mesh.children[0].material.needsUpdate = true;\n\n this._texture = texture;\n this._ready = true;\n }, false);\n\n // image.addEventListener('progress', event => {}, false);\n // image.addEventListener('error', event => {}, false);\n\n image.crossOrigin = '';\n\n // Load image\n image.src = url;\n\n this._image = image;\n }\n\n _abortRequest() {\n if (!this._image) {\n return;\n }\n\n this._image.src = '';\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(quadcode, path, layer) {\n return new ImageTile(quadcode, path, layer);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/ImageTile.js\n **/","import Point from '../../geo/Point';\nimport LatLon from '../../geo/LatLon';\nimport THREE from 'three';\n\n// Manages a single tile and its layers\n\nvar r2d = 180 / Math.PI;\n\nvar tileURLRegex = /\\{([szxy])\\}/g;\n\nclass Tile {\n constructor(quadcode, path, layer) {\n this._layer = layer;\n this._world = layer._world;\n this._quadcode = quadcode;\n this._path = path;\n\n this._ready = false;\n\n this._tile = this._quadcodeToTile(quadcode);\n\n // Bottom-left and top-right bounds in WGS84 coordinates\n this._boundsLatLon = this._tileBoundsWGS84(this._tile);\n\n // Bottom-left and top-right bounds in world coordinates\n this._boundsWorld = this._tileBoundsFromWGS84(this._boundsLatLon);\n\n // Tile center in world coordinates\n this._center = this._boundsToCenter(this._boundsWorld);\n\n // Tile center in projected coordinates\n this._centerLatlon = this._world.pointToLatLon(VIZI.Point(this._center[0], this._center[1]));\n\n // Length of a tile side in world coorindates\n this._side = this._getSide(this._boundsWorld);\n\n // Point scale for tile (for unit conversion)\n this._pointScale = this._world.pointScale(this._centerLatlon);\n }\n\n // Returns true if the tile mesh and texture are ready to be used\n // Otherwise, returns false\n isReady() {\n return this._ready;\n }\n\n // Request data for the tile\n requestTileAsync() {}\n\n getQuadcode() {\n return this._quadcode;\n }\n\n getBounds() {\n return this._boundsWorld;\n }\n\n getCenter() {\n return this._center;\n }\n\n getSide() {\n return this._side;\n }\n\n getMesh() {\n return this._mesh;\n }\n\n // Destroys the tile and removes it from the layer and memory\n //\n // Ensure that this leaves no trace of the tile – no textures, no meshes,\n // nothing in memory or the GPU\n destroy() {\n // Delete reference to layer and world\n this._layer = null;\n this._world = null;\n\n // Delete location references\n this._boundsLatLon = null;\n this._boundsWorld = null;\n this._center = null;\n\n // Done if no mesh\n if (!this._mesh) {\n return;\n }\n\n if (this._mesh.children) {\n // Dispose of mesh and materials\n this._mesh.children.forEach(child => {\n child.geometry.dispose();\n child.geometry = null;\n\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 } else {\n this._mesh.geometry.dispose();\n this._mesh.geometry = null;\n\n if (this._mesh.material.map) {\n this._mesh.material.map.dispose();\n this._mesh.material.map = null;\n }\n\n this._mesh.material.dispose();\n this._mesh.material = null;\n }\n }\n\n _createMesh() {}\n _createDebugMesh() {}\n\n _getTileURL(urlParams) {\n if (!urlParams.s) {\n // Default to a random choice of a, b or c\n urlParams.s = String.fromCharCode(97 + Math.floor(Math.random() * 3));\n }\n\n tileURLRegex.lastIndex = 0;\n return this._path.replace(tileURLRegex, function(value, key) {\n // Replace with paramter, otherwise keep existing value\n return urlParams[key];\n });\n }\n\n // Convert from quadcode to TMS tile coordinates\n _quadcodeToTile(quadcode) {\n var x = 0;\n var y = 0;\n var z = quadcode.length;\n\n for (var i = z; i > 0; i--) {\n var mask = 1 << (i - 1);\n var q = +quadcode[z - i];\n if (q === 1) {\n x |= mask;\n }\n if (q === 2) {\n y |= mask;\n }\n if (q === 3) {\n x |= mask;\n y |= mask;\n }\n }\n\n return [x, y, z];\n }\n\n // Convert WGS84 tile bounds to world coordinates\n _tileBoundsFromWGS84(boundsWGS84) {\n var sw = this._layer._world.latLonToPoint(LatLon(boundsWGS84[1], boundsWGS84[0]));\n var ne = this._layer._world.latLonToPoint(LatLon(boundsWGS84[3], boundsWGS84[2]));\n\n return [sw.x, sw.y, ne.x, ne.y];\n }\n\n // Get tile bounds in WGS84 coordinates\n _tileBoundsWGS84(tile) {\n var e = this._tile2lon(tile[0] + 1, tile[2]);\n var w = this._tile2lon(tile[0], tile[2]);\n var s = this._tile2lat(tile[1] + 1, tile[2]);\n var n = this._tile2lat(tile[1], tile[2]);\n return [w, s, e, n];\n }\n\n _tile2lon(x, z) {\n return x / Math.pow(2, z) * 360 - 180;\n }\n\n _tile2lat(y, z) {\n var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);\n return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));\n }\n\n _boundsToCenter(bounds) {\n var x = bounds[0] + (bounds[2] - bounds[0]) / 2;\n var y = bounds[1] + (bounds[3] - bounds[1]) / 2;\n\n return [x, y];\n }\n\n _getSide(bounds) {\n return (new THREE.Vector3(bounds[0], 0, bounds[3])).sub(new THREE.Vector3(bounds[0], 0, bounds[1])).length();\n }\n}\n\nexport default Tile;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/Tile.js\n **/","// jscs:disable\n/*eslint eqeqeq:0*/\n\nimport THREE from 'three';\n\n/**\n * @author mrdoob / http://mrdoob.com/\n */\n\nBoxHelper = function ( object ) {\n\n\tvar indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\n\tvar positions = new Float32Array( 8 * 3 );\n\n\tvar geometry = new THREE.BufferGeometry();\n\tgeometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );\n\tgeometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );\n\n\tTHREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { linewidth: 2, color: 0xff0000 } ) );\n\n\tif ( object !== undefined ) {\n\n\t\tthis.update( object );\n\n\t}\n\n};\n\nBoxHelper.prototype = Object.create( THREE.LineSegments.prototype );\nBoxHelper.prototype.constructor = BoxHelper;\n\nBoxHelper.prototype.update = ( function () {\n\n\tvar box = new THREE.Box3();\n\n\treturn function ( object ) {\n\n\t\tbox.setFromObject( object );\n\n\t\tif ( box.isEmpty() ) return;\n\n\t\tvar min = box.min;\n\t\tvar max = box.max;\n\n\t\t/*\n\t\t 5____4\n\t\t1/___0/|\n\t\t| 6__|_7\n\t\t2/___3/\n\n\t\t0: max.x, max.y, max.z\n\t\t1: min.x, max.y, max.z\n\t\t2: min.x, min.y, max.z\n\t\t3: max.x, min.y, max.z\n\t\t4: max.x, max.y, min.z\n\t\t5: min.x, max.y, min.z\n\t\t6: min.x, min.y, min.z\n\t\t7: max.x, min.y, min.z\n\t\t*/\n\n\t\tvar position = this.geometry.attributes.position;\n\t\tvar array = position.array;\n\n\t\tarray[ 0 ] = max.x; array[ 1 ] = max.y; array[ 2 ] = max.z;\n\t\tarray[ 3 ] = min.x; array[ 4 ] = max.y; array[ 5 ] = max.z;\n\t\tarray[ 6 ] = min.x; array[ 7 ] = min.y; array[ 8 ] = max.z;\n\t\tarray[ 9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;\n\t\tarray[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;\n\t\tarray[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;\n\t\tarray[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;\n\t\tarray[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;\n\n\t\tposition.needsUpdate = true;\n\n\t\tthis.geometry.computeBoundingSphere();\n\n\t};\n\n} )();\n\nexport default BoxHelper;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/vendor/BoxHelper.js\n **/","import THREE from 'three';\n\nexport default function(colour, skyboxTarget) {\n var canvas = document.createElement('canvas');\n canvas.width = 1;\n canvas.height = 1;\n\n var context = canvas.getContext('2d');\n context.fillStyle = colour;\n context.fillRect(0, 0, canvas.width, canvas.height);\n // context.strokeStyle = '#D0D0CF';\n // context.strokeRect(0, 0, canvas.width, canvas.height);\n\n var texture = new THREE.Texture(canvas);\n\n // // Silky smooth images when tilted\n // texture.magFilter = THREE.LinearFilter;\n // texture.minFilter = THREE.LinearMipMapLinearFilter;\n // //\n // // // TODO: Set this to renderer.getMaxAnisotropy() / 4\n // texture.anisotropy = 4;\n\n // texture.wrapS = THREE.RepeatWrapping;\n // texture.wrapT = THREE.RepeatWrapping;\n // texture.repeat.set(segments, segments);\n\n texture.needsUpdate = true;\n\n var material;\n\n if (!skyboxTarget) {\n material = new THREE.MeshBasicMaterial({\n map: texture,\n depthWrite: false\n });\n } else {\n material = new THREE.MeshStandardMaterial({\n depthWrite: false\n });\n material.roughness = 1;\n material.metalness = 0.1;\n material.envMap = skyboxTarget;\n }\n\n return material;\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/ImageTileLayerBaseMaterial.js\n **/","import TileLayer from './TileLayer';\nimport extend from 'lodash.assign';\nimport TopoJSONTile from './TopoJSONTile';\nimport throttle from 'lodash.throttle';\nimport THREE from 'three';\n\nclass TopoJSONTileLayer extends TileLayer {\n constructor(path, options) {\n var defaults = {\n maxLOD: 14,\n distance: 2000\n };\n\n options = extend(defaults, options);\n\n super(options);\n\n this._path = path;\n }\n\n _onAdd(world) {\n super._onAdd(world);\n\n // Trigger initial quadtree calculation on the next frame\n //\n // TODO: This is a hack to ensure the camera is all set up - a better\n // solution should be found\n setTimeout(() => {\n this._calculateLOD();\n this._initEvents();\n }, 0);\n }\n\n _initEvents() {\n // Run LOD calculations based on render calls\n //\n // Throttled to 1 LOD calculation per 100ms\n this._throttledWorldUpdate = throttle(this._onWorldUpdate, 100);\n\n this._world.on('preUpdate', this._throttledWorldUpdate, this);\n this._world.on('move', this._onWorldMove, this);\n }\n\n _onWorldUpdate() {\n this._calculateLOD();\n }\n\n _onWorldMove(latlon, point) {}\n\n _createTile(quadcode, layer) {\n var options = {};\n\n if (this._options.filter) {\n options.filter = this._options.filter;\n }\n\n if (this._options.style) {\n options.style = this._options.style;\n }\n\n return TopoJSONTile(quadcode, this._path, layer, options);\n }\n\n // Destroys the layer and removes it from the scene and memory\n destroy() {\n this._world.off('preUpdate', this._throttledWorldUpdate);\n this._world.off('move', this._onWorldMove);\n\n this._throttledWorldUpdate = null;\n\n // Run common destruction logic from parent\n super.destroy();\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(path, options) {\n return new TopoJSONTileLayer(path, options);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/TopoJSONTileLayer.js\n **/","import Tile from './Tile';\nimport BoxHelper from '../../vendor/BoxHelper';\nimport THREE from 'three';\nimport reqwest from 'reqwest';\nimport topojson from 'topojson';\nimport Point from '../../geo/Point';\nimport LatLon from '../../geo/LatLon';\nimport earcut from 'earcut';\nimport extend from 'lodash.assign';\nimport extrudePolygon from '../../util/extrudePolygon';\nimport Offset from 'polygon-offset';\n\n// TODO: Perform tile request and processing in a Web Worker\n//\n// Use Operative (https://github.com/padolsey/operative)\n//\n// Would it make sense to have the worker functionality defined in a static\n// method so it only gets initialised once and not on every tile instance?\n//\n// Otherwise, worker processing logic would have to go in the tile layer so not\n// to waste loads of time setting up a brand new worker with three.js for each\n// tile every single time.\n//\n// Unsure of the best way to get three.js and VIZI into the worker\n//\n// Would need to set up a CRS / projection identical to the world instance\n//\n// Is it possible to bypass requirements on external script by having multiple\n// simple worker methods that each take enough inputs to perform a single task\n// without requiring VIZI or three.js? So long as the heaviest logic is done in\n// the worker and transferrable objects are used then it should be better than\n// nothing. Would probably still need things like earcut...\n//\n// After all, the three.js logic and object creation will still need to be\n// done on the main thread regardless so the worker should try to do as much as\n// possible with as few dependencies as possible.\n//\n// Have a look at how this is done in Tangram before implementing anything as\n// the approach there is pretty similar and robust.\n\nclass TopoJSONTile extends Tile {\n constructor(quadcode, path, layer, options) {\n super(quadcode, path, layer);\n\n var defaults = {\n filter: null,\n style: {\n color: '#ffffff'\n }\n };\n\n this._options = extend(defaults, options);\n }\n\n // Request data for the tile\n requestTileAsync() {\n // Making this asynchronous really speeds up the LOD framerate\n setTimeout(() => {\n if (!this._mesh) {\n this._mesh = this._createMesh();\n // this._shadowCanvas = this._createShadowCanvas();\n this._requestTile();\n }\n }, 0);\n }\n\n destroy() {\n // Cancel any pending requests\n this._abortRequest();\n\n // Clear request reference\n this._request = null;\n\n super.destroy();\n }\n\n _createMesh() {\n // Something went wrong and the tile\n //\n // Possibly removed by the cache before loaded\n if (!this._center) {\n return;\n }\n\n var mesh = new THREE.Object3D();\n\n mesh.position.x = this._center[0];\n mesh.position.z = this._center[1];\n\n // var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n //\n // var material = new THREE.MeshBasicMaterial({\n // depthWrite: false\n // });\n //\n // var localMesh = new THREE.Mesh(geom, material);\n // localMesh.rotation.x = -90 * Math.PI / 180;\n //\n // mesh.add(localMesh);\n //\n // var box = new BoxHelper(localMesh);\n // mesh.add(box);\n //\n // mesh.add(this._createDebugMesh());\n\n return mesh;\n }\n\n _createDebugMesh() {\n var canvas = document.createElement('canvas');\n canvas.width = 256;\n canvas.height = 256;\n\n var context = canvas.getContext('2d');\n context.font = 'Bold 20px Helvetica Neue, Verdana, Arial';\n context.fillStyle = '#ff0000';\n context.fillText(this._quadcode, 20, canvas.width / 2 - 5);\n context.fillText(this._tile.toString(), 20, canvas.width / 2 + 25);\n\n var texture = new THREE.Texture(canvas);\n\n // Silky smooth images when tilted\n texture.magFilter = THREE.LinearFilter;\n texture.minFilter = THREE.LinearMipMapLinearFilter;\n\n // TODO: Set this to renderer.getMaxAnisotropy() / 4\n texture.anisotropy = 4;\n\n texture.needsUpdate = true;\n\n var material = new THREE.MeshBasicMaterial({\n map: texture,\n transparent: true,\n depthWrite: false\n });\n\n var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n var mesh = new THREE.Mesh(geom, material);\n\n mesh.rotation.x = -90 * Math.PI / 180;\n mesh.position.y = 0.1;\n\n return mesh;\n }\n\n _createShadowCanvas() {\n var canvas = document.createElement('canvas');\n\n // Rendered at a low resolution and later scaled up for a low-quality blur\n canvas.width = 512;\n canvas.height = 512;\n\n return canvas;\n }\n\n _addShadow(coordinates) {\n var ctx = this._shadowCanvas.getContext('2d');\n var width = this._shadowCanvas.width;\n var height = this._shadowCanvas.height;\n\n var _coords;\n var _offset;\n var offset = new Offset();\n\n // Transform coordinates to shadowCanvas space and draw on canvas\n coordinates.forEach((ring, index) => {\n ctx.beginPath();\n\n _coords = ring.map(coord => {\n var xFrac = (coord[0] - this._boundsWorld[0]) / this._side;\n var yFrac = (coord[1] - this._boundsWorld[3]) / this._side;\n return [xFrac * width, yFrac * height];\n });\n\n if (index > 0) {\n _offset = _coords;\n } else {\n _offset = offset.data(_coords).padding(1.3);\n }\n\n // TODO: This is super flaky and crashes the browser if run on anything\n // put the outer ring (potentially due to winding)\n _offset.forEach((coord, index) => {\n // var xFrac = (coord[0] - this._boundsWorld[0]) / this._side;\n // var yFrac = (coord[1] - this._boundsWorld[3]) / this._side;\n\n if (index === 0) {\n ctx.moveTo(coord[0], coord[1]);\n } else {\n ctx.lineTo(coord[0], coord[1]);\n }\n });\n\n ctx.closePath();\n });\n\n ctx.fillStyle = 'rgba(80, 80, 80, 0.7)';\n ctx.fill();\n }\n\n _requestTile() {\n var urlParams = {\n x: this._tile[0],\n y: this._tile[1],\n z: this._tile[2]\n };\n\n var url = this._getTileURL(urlParams);\n\n this._request = reqwest({\n url: url,\n type: 'json',\n crossOrigin: true\n }).then(res => {\n // Clear request reference\n this._request = null;\n this._processTileData(res);\n }).catch(err => {\n console.error(err);\n\n // Clear request reference\n this._request = null;\n });\n }\n\n _processTileData(data) {\n console.time(this._tile);\n\n var geojson = topojson.feature(data, data.objects.vectile);\n\n var offset = Point(0, 0);\n offset.x = -1 * this._center[0];\n offset.y = -1 * this._center[1];\n\n var coordinates;\n var earcutData;\n var faces;\n\n var allVertices = [];\n var allFaces = [];\n var allColours = [];\n var facesCount = 0;\n\n var colour = new THREE.Color();\n\n var light = new THREE.Color(0xffffff);\n var shadow = new THREE.Color(0x666666);\n\n var features = geojson.features;\n\n // Run filter, if provided\n if (this._options.filter) {\n features = geojson.features.filter(this._options.filter);\n }\n\n var style = this._options.style;\n\n features.forEach(feature => {\n // feature.geometry, feature.properties\n\n // Get style object, if provided\n if (typeof this._options.style === 'function') {\n style = this._options.style(feature);\n }\n\n var coordinates = feature.geometry.coordinates;\n\n // Skip if geometry is a point\n //\n // This should be a user-defined filter as it would be wrong to assume\n // that people won't want to output points\n //\n // The default use-case should be to output points in a different way\n if (!coordinates[0] || !coordinates[0][0] || !Array.isArray(coordinates[0][0])) {\n return;\n }\n\n coordinates = coordinates.map(ring => {\n return ring.map(coordinate => {\n var latlon = LatLon(coordinate[1], coordinate[0]);\n var point = this._layer._world.latLonToPoint(latlon);\n return [point.x, point.y];\n });\n });\n\n // Draw footprint on shadow canvas\n //\n // TODO: Disabled for the time-being until it can be sped up / moved to\n // a worker\n // this._addShadow(coordinates);\n\n earcutData = this._toEarcut(coordinates);\n\n faces = this._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 height = 0;\n\n if (style.height) {\n height = this._world.metresToWorld(style.height, this._pointScale);\n }\n\n var extruded = extrudePolygon(groupedVertices, faces, {\n bottom: 0,\n top: height\n });\n\n colour.set(style.color);\n\n var topColor = colour.clone().multiply(light);\n var bottomColor = colour.clone().multiply(shadow);\n\n var _faces = [];\n var _colours = [];\n\n allVertices.push(extruded.positions);\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 // 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 // Skip bottom as there's no point rendering it\n // allFaces.push(extruded.faces);\n\n allFaces.push(_faces);\n allColours.push(_colours);\n\n facesCount += _faces.length;\n });\n\n // Output shadow canvas\n //\n // TODO: Disabled for the time-being until it can be sped up / moved to\n // a worker\n\n // var texture = new THREE.Texture(this._shadowCanvas);\n //\n // // Silky smooth images when tilted\n // texture.magFilter = THREE.LinearFilter;\n // texture.minFilter = THREE.LinearMipMapLinearFilter;\n //\n // // TODO: Set this to renderer.getMaxAnisotropy() / 4\n // texture.anisotropy = 4;\n //\n // texture.needsUpdate = true;\n //\n // var material;\n // if (!this._world._environment._skybox) {\n // material = new THREE.MeshBasicMaterial({\n // map: texture,\n // transparent: true,\n // depthWrite: false\n // });\n // } else {\n // material = new THREE.MeshStandardMaterial({\n // map: texture,\n // transparent: true,\n // depthWrite: false\n // });\n // material.roughness = 1;\n // material.metalness = 0.1;\n // material.envMap = this._world._environment._skybox.getRenderTarget();\n // }\n //\n // var geom = new THREE.PlaneBufferGeometry(this._side, this._side, 1);\n // var mesh = new THREE.Mesh(geom, material);\n //\n // mesh.castShadow = false;\n // mesh.receiveShadow = false;\n // mesh.renderOrder = 1;\n //\n // mesh.rotation.x = -90 * Math.PI / 180;\n //\n // this._mesh.add(mesh);\n\n // Skip if no faces\n //\n // Need to check way before this if there are no faces, before even doing\n // earcut triangulation.\n if (facesCount === 0) {\n this._ready = true;\n return;\n }\n\n var geometry = new THREE.BufferGeometry();\n\n // Three components per vertex per face (3 x 3 = 9)\n var vertices = new Float32Array(facesCount * 9);\n var normals = new Float32Array(facesCount * 9);\n var colours = new Float32Array(facesCount * 9);\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 dim = 2;\n\n var index;\n var _faces;\n var _vertices;\n var _colour;\n var lastIndex = 0;\n for (var i = 0; i < allFaces.length; i++) {\n _faces = allFaces[i];\n _vertices = allVertices[i];\n _colour = allColours[i];\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 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 geometry.computeBoundingBox();\n\n var material;\n if (!this._world._environment._skybox) {\n material = new THREE.MeshPhongMaterial({\n vertexColors: THREE.VertexColors,\n side: THREE.BackSide\n });\n } else {\n material = new THREE.MeshStandardMaterial({\n vertexColors: THREE.VertexColors,\n side: THREE.BackSide\n });\n material.roughness = 1;\n material.metalness = 0.1;\n material.envMapIntensity = 3;\n material.envMap = this._world._environment._skybox.getRenderTarget();\n }\n\n var mesh = new THREE.Mesh(geometry, material);\n\n mesh.castShadow = true;\n mesh.receiveShadow = true;\n\n // This is only useful for flat objects\n // mesh.renderOrder = 1;\n\n this._mesh.add(mesh);\n\n this._ready = true;\n console.timeEnd(this._tile);\n console.log(`${this._tile}: ${features.length} features`);\n }\n\n _toEarcut(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 _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 _abortRequest() {\n if (!this._request) {\n return;\n }\n\n this._request.abort();\n }\n}\n\n// Initialise without requiring new keyword\nexport default function(quadcode, path, layer, options) {\n return new TopoJSONTile(quadcode, path, layer, options);\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/layer/tile/TopoJSONTile.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 = 54\n ** module chunks = 0\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 = {})));\n}(this, function (exports) { 'use strict';\n\n function noop() {}\n\n function absolute(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\n function relative(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 = (point[0] - dx) / kx | 0,\n y1 = (point[1] - dy) / ky | 0;\n point[0] = x1 - x0;\n point[1] = y1 - y0;\n x0 = x1;\n y0 = y1;\n };\n }\n\n function 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\n function 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\n function 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\n function 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\n function object(topology, o) {\n var absolute$$ = absolute(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\n function 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\n function mesh(topology) {\n return object(topology, meshArcs.apply(this, arguments));\n }\n\n function 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\n function triangle(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\n function 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\n function merge(topology) {\n return object(topology, mergeArcs.apply(this, arguments));\n }\n\n function 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 exterior(ring$$) {\n return ring(object(topology, {type: \"Polygon\", arcs: [ring$$]}).coordinates[0]) > 0; // TODO allow spherical?\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 // this exterior ring has the same winding order\n // as any exterior ring in the original polygons.\n if ((n = arcs.length) > 1) {\n var sgn = exterior(polygons[0][0]);\n for (var i = 0, t; i < n; ++i) {\n if (sgn === exterior(arcs[i])) {\n t = arcs[0], arcs[0] = arcs[i], arcs[i] = t;\n break;\n }\n }\n }\n\n return arcs;\n })\n };\n }\n\n function 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\n function compareArea(a, b) {\n return a[1][2] - b[1][2];\n }\n\n function 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\n function presimplify(topology, triangleArea) {\n var absolute$$ = absolute(topology.transform),\n relative$$ = relative(topology.transform),\n heap = minAreaHeap();\n\n if (!triangleArea) triangleArea = triangle;\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\n var version = \"1.6.24\";\n\n exports.version = version;\n exports.mesh = mesh;\n exports.meshArcs = meshArcs;\n exports.merge = merge;\n exports.mergeArcs = mergeArcs;\n exports.feature = feature;\n exports.neighbors = neighbors;\n exports.presimplify = presimplify;\n\n}));\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/topojson/build/topojson.js\n ** module id = 56\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 sum = 0,\n i, j, last;\n\n // calculate original winding order of a polygon ring\n for (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\n // link points into circular doubly-linked list in the specified winding order\n if (clockwise === (sum > 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 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 // a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])\n if (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 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 (hole.x === m.x) 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 tanMin = Infinity,\n tan;\n\n p = m.next;\n\n while (p !== stop) {\n if (hx >= p.x && p.x >= m.x &&\n pointInTriangle(hy < m.y ? hx : qx, hy, m.x, m.y, hy < m.y ? 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 equals(a, b) || 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 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\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/earcut/src/earcut.js\n ** module id = 57\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 **/","var GreinerHormann = require('greiner-hormann');\nvar Edge = require('./edge');\nvar intersection = require('./intersection');\n\n\"use strict\";\n\nvar min = Math.min,\n max = Math.max,\n atan2 = Math.atan2;\n\n/**\n * Offset builder\n *\n * @param {Array.<Object>=} vertices\n * @param {Number=} arcSegments\n * @constructor\n */\nfunction Offset(vertices, arcSegments) {\n\n /**\n * @type {Array.<Object>}\n */\n this.vertices = null;\n\n /**\n * @type {Array.<Edge>}\n */\n this.edges = null;\n\n /**\n * @type {Boolean}\n */\n this._closed = false;\n\n if (vertices) {\n this.data(vertices);\n }\n\n /**\n * Segments in edge bounding arches\n * @type {Number}\n */\n this._arcSegments = arcSegments || 5;\n};\n\n/**\n * Change data set\n * @param {Array.<Array>} vertices\n * @return {Offset}\n */\nOffset.prototype.data = function(vertices) {\n vertices = this.validate(vertices);\n\n var edges = [];\n for (var i = 0, len = vertices.length; i < len; i++) {\n edges.push(new Edge(vertices[i], vertices[(i + 1) % len]));\n }\n\n this.vertices = vertices;\n this.edges = edges;\n return this;\n};\n\n/**\n * @param {Number} arcSegments\n * @return {Offset}\n */\nOffset.prototype.arcSegments = function(arcSegments) {\n this._arcSegments = arcSegments;\n return this;\n};\n\n/**\n * Validates if the first and last points repeat\n * TODO: check CCW\n *\n * @param {Array.<Object>} vertices\n */\nOffset.prototype.validate = function(vertices) {\n var len = vertices.length;\n if (vertices[0][0] === vertices[len - 1][0] &&\n vertices[0][1] === vertices[len - 1][1]) {\n vertices = vertices.slice(0, len - 1);\n this._closed = true;\n }\n return vertices;\n};\n\n/**\n * Creates arch between two edges\n *\n * @param {Array.<Object>} vertices\n * @param {Object} center\n * @param {Number} radius\n * @param {Object} startVertex\n * @param {Object} endVertex\n * @param {Number} segments\n * @param {Boolean} outwards\n */\nOffset.prototype.createArc = function(vertices, center, radius, startVertex,\n endVertex, segments, outwards) {\n\n var PI2 = Math.PI * 2,\n startAngle = atan2(startVertex[1] - center[1], startVertex[0] - center[0]),\n endAngle = atan2(endVertex[1] - center[1], endVertex[0] - center[0]);\n\n // odd number please\n if (segments % 2 === 0) {\n segments -= 1;\n }\n\n if (startAngle < 0) {\n startAngle += PI2;\n }\n\n if (endAngle < 0) {\n endAngle += PI2;\n }\n\n var angle = ((startAngle > endAngle) ?\n (startAngle - endAngle) :\n (startAngle + PI2 - endAngle)),\n segmentAngle = ((outwards) ? -angle : PI2 - angle) / segments;\n\n vertices.push(startVertex);\n for (var i = 1; i < segments; ++i) {\n angle = startAngle + segmentAngle * i;\n vertices.push([\n center[0] + Math.cos(angle) * radius,\n center[1] + Math.sin(angle) * radius\n ]);\n }\n vertices.push(endVertex);\n};\n\n/**\n * Create padding polygon\n *\n * @param {Number} distance\n * @return {Array.<Number>}\n */\nOffset.prototype.padding = function(dist) {\n var offsetEdges = [],\n vertices = [],\n i, len, union;\n\n for (i = 0, len = this.edges.length; i < len; i++) {\n var edge = this.edges[i],\n dx = edge._outNormal[0] * dist,\n dy = edge._outNormal[1] * dist;\n offsetEdges.push(edge.offset(dx, dy));\n }\n\n for (i = 0, len = offsetEdges.length; i < len; i++) {\n var thisEdge = offsetEdges[i],\n prevEdge = offsetEdges[(i + len - 1) % len],\n vertex = intersection(\n prevEdge.current,\n prevEdge.next,\n thisEdge.current,\n thisEdge.next);\n\n if (vertex)\n vertices.push(vertex);\n else {\n this.createArc(\n vertices,\n this.edges[i].current,\n dist,\n prevEdge.next,\n thisEdge.current,\n this._arcSegments,\n false);\n }\n }\n union = GreinerHormann.union(vertices, vertices);\n vertices = union ? union[0] : vertices;\n\n vertices = this.ensureLastPoint(vertices);\n return vertices;\n};\n\n/**\n * Creates margin polygon\n * @param {Number} dist\n * @return {Array.<Object>}\n */\nOffset.prototype.margin = function(dist) {\n var offsetEdges = [],\n vertices = [],\n i, len, union;\n for (i = 0, len = this.edges.length; i < len; i++) {\n var edge = this.edges[i],\n dx = edge._inNormal[0] * dist,\n dy = edge._inNormal[1] * dist;\n\n offsetEdges.push(edge.offset(dx, dy));\n }\n\n for (i = 0, len = offsetEdges.length; i < len; i++) {\n var thisEdge = offsetEdges[i],\n prevEdge = offsetEdges[(i + len - 1) % len],\n vertex = intersection(\n prevEdge.current,\n prevEdge.next,\n thisEdge.current,\n thisEdge.next\n );\n\n if (vertex) {\n vertices.push(vertex);\n } else {\n this.createArc(\n vertices,\n this.edges[i].current,\n dist,\n prevEdge.next,\n thisEdge.current,\n this._arcSegments,\n true\n );\n }\n }\n\n union = GreinerHormann.union(vertices, vertices);\n if (union) {\n union = union[0];\n // that's the toll\n vertices = union.slice(0, union.length / 2);\n }\n\n vertices = this.ensureLastPoint(vertices);\n return vertices;\n};\n\n/**\n * @param {Array.<Object>} vertices\n * @return {Array.<Object>}\n */\nOffset.prototype.ensureLastPoint = function(vertices) {\n if (this._closed) {\n vertices.push([\n vertices[0][0],\n vertices[0][1]\n ]);\n }\n return vertices;\n};\n\n/**\n * Decides by the sign if it's a padding or a margin\n *\n * @param {Number} dist\n * @return {Array.<Object>}\n */\nOffset.prototype.offset = function(dist) {\n return dist === 0 ?\n this.vertices :\n (dist > 0 ? this.margin(dist) : this.padding(-dist));\n};\n\nmodule.exports = Offset;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/src/offset.js\n ** module id = 59\n ** module chunks = 0\n **/","var clip = require('./clip');\n\nmodule.exports = {\n /**\n * @api\n * @param {Array.<Array.<Number>|Array.<Object>} polygonA\n * @param {Array.<Array.<Number>|Array.<Object>} polygonB\n * @return {Array.<Array.<Number>>|Array.<Array.<Object>|Null}\n */\n union: function(polygonA, polygonB) {\n return clip(polygonA, polygonB, false, false);\n },\n\n /**\n * @api\n * @param {Array.<Array.<Number>|Array.<Object>} polygonA\n * @param {Array.<Array.<Number>|Array.<Object>} polygonB\n * @return {Array.<Array.<Number>>|Array.<Array.<Object>>|Null}\n */\n intersection: function(polygonA, polygonB) {\n return clip(polygonA, polygonB, true, true);\n },\n\n /**\n * @api\n * @param {Array.<Array.<Number>|Array.<Object>} polygonA\n * @param {Array.<Array.<Number>|Array.<Object>} polygonB\n * @return {Array.<Array.<Number>>|Array.<Array.<Object>>|Null}\n */\n diff: function(polygonA, polygonB) {\n return clip(polygonA, polygonB, false, true);\n },\n\n clip: clip\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/~/greiner-hormann/src/greiner-hormann.js\n ** module id = 60\n ** module chunks = 0\n **/","var Polygon = require('./polygon');\n\n/**\n * Clip driver\n * @api\n * @param {Array.<Array.<Number>>} polygonA\n * @param {Array.<Array.<Number>>} polygonB\n * @param {Boolean} sourceForwards\n * @param {Boolean} clipForwards\n * @return {Array.<Array.<Number>>}\n */\nmodule.exports = function(polygonA, polygonB, eA, eB) {\n var result, source = new Polygon(polygonA),\n clip = new Polygon(polygonB),\n result = source.clip(clip, eA, eB);\n\n return result;\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/~/greiner-hormann/src/clip.js\n ** module id = 61\n ** module chunks = 0\n **/","var Vertex = require('./vertex');\nvar Intersection = require('./intersection');\n\n/**\n * Polygon representation\n * @param {Array.<Array.<Number>>} p\n * @param {Boolean=} arrayVertices\n *\n * @constructor\n */\nvar Polygon = function(p, arrayVertices) {\n\n /**\n * @type {Vertex}\n */\n this.first = null;\n\n /**\n * @type {Number}\n */\n this.vertices = 0;\n\n /**\n * @type {Vertex}\n */\n this._lastUnprocessed = null;\n\n /**\n * Whether to handle input and output as [x,y] or {x:x,y:y}\n * @type {Boolean}\n */\n this._arrayVertices = (typeof arrayVertices === \"undefined\") ?\n Array.isArray(p[0]) :\n arrayVertices;\n\n for (var i = 0, len = p.length; i < len; i++) {\n this.addVertex(new Vertex(p[i]));\n }\n};\n\n/**\n * Add a vertex object to the polygon\n * (vertex is added at the 'end' of the list')\n *\n * @param vertex\n */\nPolygon.prototype.addVertex = function(vertex) {\n if (this.first == null) {\n this.first = vertex;\n this.first.next = vertex;\n this.first.prev = vertex;\n } else {\n var next = this.first,\n prev = next.prev;\n\n next.prev = vertex;\n vertex.next = next;\n vertex.prev = prev;\n prev.next = vertex;\n }\n this.vertices++;\n};\n\n/**\n * Inserts a vertex inbetween start and end\n *\n * @param {Vertex} vertex\n * @param {Vertex} start\n * @param {Vertex} end\n */\nPolygon.prototype.insertVertex = function(vertex, start, end) {\n var prev, curr = start;\n\n while (!curr.equals(end) && curr._distance < vertex._distance) {\n curr = curr.next;\n }\n\n vertex.next = curr;\n prev = curr.prev;\n\n vertex.prev = prev;\n prev.next = vertex;\n curr.prev = vertex;\n\n this.vertices++;\n};\n\n/**\n * Get next non-intersection point\n * @param {Vertex} v\n * @return {Vertex}\n */\nPolygon.prototype.getNext = function(v) {\n var c = v;\n while (c._isIntersection) {\n c = c.next;\n }\n return c;\n};\n\n/**\n * Unvisited intersection\n * @return {Vertex}\n */\nPolygon.prototype.getFirstIntersect = function() {\n var v = this._firstIntersect || this.first;\n\n do {\n if (v._isIntersection && !v._visited) {\n break;\n }\n\n v = v.next;\n } while (!v.equals(this.first));\n\n this._firstIntersect = v;\n return v;\n};\n\n/**\n * Does the polygon have unvisited vertices\n * @return {Boolean} [description]\n */\nPolygon.prototype.hasUnprocessed = function() {\n var v = this._lastUnprocessed || this.first;\n do {\n if (v._isIntersection && !v._visited) {\n this._lastUnprocessed = v;\n return true;\n }\n\n v = v.next;\n } while (!v.equals(this.first));\n\n this._lastUnprocessed = null;\n return false;\n};\n\n/**\n * The output depends on what you put in, arrays or objects\n * @return {Array.<Array<Number>|Array.<Object>}\n */\nPolygon.prototype.getPoints = function() {\n var points = [],\n v = this.first;\n\n if (this._arrayVertices) {\n do {\n points.push([v.x, v.y]);\n v = v.next;\n } while (v !== this.first);\n } else {\n do {\n points.push({\n x: v.x,\n y: v.y\n });\n v = v.next;\n } while (v !== this.first);\n }\n\n return points;\n};\n\n/**\n * Clip polygon against another one.\n * Result depends on algorithm direction:\n *\n * Intersection: forwards forwards\n * Union: backwars backwards\n * Diff: backwards forwards\n *\n * @param {Polygon} clip\n * @param {Boolean} sourceForwards\n * @param {Boolean} clipForwards\n */\nPolygon.prototype.clip = function(clip, sourceForwards, clipForwards) {\n var sourceVertex = this.first,\n clipVertex = clip.first,\n sourceInClip, clipInSource;\n\n // calculate and mark intersections\n do {\n if (!sourceVertex._isIntersection) {\n do {\n if (!clipVertex._isIntersection) {\n var i = new Intersection(\n sourceVertex,\n this.getNext(sourceVertex.next),\n clipVertex, clip.getNext(clipVertex.next));\n\n if (i.valid()) {\n var sourceIntersection =\n Vertex.createIntersection(i.x, i.y, i.toSource),\n clipIntersection =\n Vertex.createIntersection(i.x, i.y, i.toClip);\n\n sourceIntersection._corresponding = clipIntersection;\n clipIntersection._corresponding = sourceIntersection;\n\n this.insertVertex(\n sourceIntersection,\n sourceVertex,\n this.getNext(sourceVertex.next));\n clip.insertVertex(\n clipIntersection,\n clipVertex,\n clip.getNext(clipVertex.next));\n }\n }\n clipVertex = clipVertex.next;\n } while (!clipVertex.equals(clip.first));\n }\n\n sourceVertex = sourceVertex.next;\n } while (!sourceVertex.equals(this.first));\n\n // phase two - identify entry/exit points\n sourceVertex = this.first;\n clipVertex = clip.first;\n\n sourceInClip = sourceVertex.isInside(clip);\n clipInSource = clipVertex.isInside(this);\n\n sourceForwards ^= sourceInClip;\n clipForwards ^= clipInSource;\n\n do {\n if (sourceVertex._isIntersection) {\n sourceVertex._isEntry = sourceForwards;\n sourceForwards = !sourceForwards;\n }\n sourceVertex = sourceVertex.next;\n } while (!sourceVertex.equals(this.first));\n\n do {\n if (clipVertex._isIntersection) {\n clipVertex._isEntry = clipForwards;\n clipForwards = !clipForwards;\n }\n clipVertex = clipVertex.next;\n } while (!clipVertex.equals(clip.first));\n\n // phase three - construct a list of clipped polygons\n var list = [];\n\n while (this.hasUnprocessed()) {\n var current = this.getFirstIntersect(),\n // keep format\n clipped = new Polygon([], this._arrayVertices);\n\n clipped.addVertex(new Vertex(current.x, current.y));\n do {\n current.visit();\n if (current._isEntry) {\n do {\n current = current.next;\n clipped.addVertex(new Vertex(current.x, current.y));\n } while (!current._isIntersection);\n\n } else {\n do {\n current = current.prev;\n clipped.addVertex(new Vertex(current.x, current.y));\n } while (!current._isIntersection);\n }\n current = current._corresponding;\n } while (!current._visited);\n\n list.push(clipped.getPoints());\n }\n\n if (list.length === 0) {\n if (sourceInClip) {\n list.push(this.getPoints());\n }\n if (clipInSource) {\n list.push(clip.getPoints());\n }\n if (list.length === 0) {\n list = null;\n }\n }\n\n return list;\n};\n\nmodule.exports = Polygon;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/~/greiner-hormann/src/polygon.js\n ** module id = 62\n ** module chunks = 0\n **/","/**\n * Vertex representation\n *\n * @param {Number|Array.<Number>} x\n * @param {Number=} y\n *\n * @constructor\n */\nvar Vertex = function(x, y) {\n\n if (arguments.length === 1) {\n // Coords\n if (Array.isArray(x)) {\n y = x[1];\n x = x[0];\n } else {\n y = x.y;\n x = x.x;\n }\n }\n\n /**\n * X coordinate\n * @type {Number}\n */\n this.x = x;\n\n /**\n * Y coordinate\n * @type {Number}\n */\n this.y = y;\n\n /**\n * Next node\n * @type {Vertex}\n */\n this.next = null;\n\n /**\n * Previous vertex\n * @type {Vertex}\n */\n this.prev = null;\n\n /**\n * Corresponding intersection in other polygon\n */\n this._corresponding = null;\n\n /**\n * Distance from previous\n */\n this._distance = 0.0;\n\n /**\n * Entry/exit point in another polygon\n * @type {Boolean}\n */\n this._isEntry = true;\n\n /**\n * Intersection vertex flag\n * @type {Boolean}\n */\n this._isIntersection = false;\n\n /**\n * Loop check\n * @type {Boolean}\n */\n this._visited = false;\n};\n\n/**\n * Creates intersection vertex\n * @param {Number} x\n * @param {Number} y\n * @param {Number} distance\n * @return {Vertex}\n */\nVertex.createIntersection = function(x, y, distance) {\n var vertex = new Vertex(x, y);\n vertex._distance = distance;\n vertex._isIntersection = true;\n vertex._isEntry = false;\n return vertex;\n};\n\n/**\n * Mark as visited\n */\nVertex.prototype.visit = function() {\n this._visited = true;\n if (this._corresponding !== null && !this._corresponding._visited) {\n this._corresponding.visit();\n }\n};\n\n/**\n * Convenience\n * @param {Vertex} v\n * @return {Boolean}\n */\nVertex.prototype.equals = function(v) {\n return this.x === v.x && this.y === v.y;\n};\n\n/**\n * Check if vertex is inside a polygon by odd-even rule:\n * If the number of intersections of a ray out of the point and polygon\n * segments is odd - the point is inside.\n * @param {Polygon} poly\n * @return {Boolean}\n */\nVertex.prototype.isInside = function(poly) {\n var oddNodes = false,\n vertex = poly.first,\n next = vertex.next,\n x = this.x,\n y = this.y;\n\n do {\n if ((vertex.y < y && next.y >= y ||\n next.y < y && vertex.y >= y) &&\n (vertex.x <= x || next.x <= x)) {\n\n oddNodes ^= (vertex.x + (y - vertex.y) /\n (next.y - vertex.y) * (next.x - vertex.x) < x);\n }\n\n vertex = vertex.next;\n next = vertex.next || poly.first;\n } while (!vertex.equals(poly.first));\n\n return oddNodes;\n};\n\nmodule.exports = Vertex;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/~/greiner-hormann/src/vertex.js\n ** module id = 63\n ** module chunks = 0\n **/","/**\n * Intersection\n * @param {Vertex} s1\n * @param {Vertex} s2\n * @param {Vertex} c1\n * @param {Vertex} c2\n * @constructor\n */\nvar Intersection = function(s1, s2, c1, c2) {\n\n /**\n * @type {Number}\n */\n this.x = 0.0;\n\n /**\n * @type {Number}\n */\n this.y = 0.0;\n\n /**\n * @type {Number}\n */\n this.toSource = 0.0;\n\n /**\n * @type {Number}\n */\n this.toClip = 0.0;\n\n var d = (c2.y - c1.y) * (s2.x - s1.x) - (c2.x - c1.x) * (s2.y - s1.y);\n\n if (d === 0) {\n return;\n }\n\n /**\n * @type {Number}\n */\n this.toSource = ((c2.x - c1.x) * (s1.y - c1.y) - (c2.y - c1.y) * (s1.x - c1.x)) / d;\n\n /**\n * @type {Number}\n */\n this.toClip = ((s2.x - s1.x) * (s1.y - c1.y) - (s2.y - s1.y) * (s1.x - c1.x)) / d;\n\n if (this.valid()) {\n this.x = s1.x + this.toSource * (s2.x - s1.x);\n this.y = s1.y + this.toSource * (s2.y - s1.y);\n }\n};\n\n/**\n * @return {Boolean}\n */\nIntersection.prototype.valid = function() {\n return (0 < this.toSource && this.toSource < 1) && (0 < this.toClip && this.toClip < 1);\n};\n\nmodule.exports = Intersection;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/~/greiner-hormann/src/intersection.js\n ** module id = 64\n ** module chunks = 0\n **/","\"use strict\";\n\n/**\n * Offset edge of the polygon\n *\n * @param {Object} current\n * @param {Object} next\n * @cosntructor\n */\nfunction Edge(current, next) {\n\n /**\n * @type {Object}\n */\n this.current = current;\n\n /**\n * @type {Object}\n */\n this.next = next;\n\n /**\n * @type {Object}\n */\n this._inNormal = this.inwardsNormal();\n\n /**\n * @type {Object}\n */\n this._outNormal = this.outwardsNormal();\n};\n\n/**\n * Creates outwards normal\n * @return {Object}\n */\nEdge.prototype.outwardsNormal = function() {\n var inwards = this.inwardsNormal();\n return [\n -inwards[0],\n -inwards[1]\n ];\n};\n\n/**\n * Creates inwards normal\n * @return {Object}\n */\nEdge.prototype.inwardsNormal = function() {\n var dx = this.next[0] - this.current[0],\n dy = this.next[1] - this.current[1],\n edgeLength = Math.sqrt(dx * dx + dy * dy);\n\n return [\n -dy / edgeLength,\n dx / edgeLength\n ];\n};\n\n/**\n * Offsets the edge by dx, dy\n * @param {Number} dx\n * @param {Number} dy\n * @return {Edge}\n */\nEdge.prototype.offset = function(dx, dy) {\n var current = this.current,\n next = this.next;\n\n return new Edge([\n current[0] + dx,\n current[1] + dy\n ], [\n next[0] + dx,\n next[1] + dy\n ]);\n};\n\nmodule.exports = Edge;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/src/edge.js\n ** module id = 65\n ** module chunks = 0\n **/","\"use strict\";\n\n/**\n * Vector intersection, if present\n *\n * @param {Object} A0\n * @param {Object} A1\n * @param {Object} B0\n * @param {Object} B1\n *\n * @return {Object|null}\n */\nmodule.exports = function intersection(A0, A1, B0, B1) {\n var den = (B1[1] - B0[1]) * (A1[0] - A0[0]) -\n (B1[0] - B0[0]) * (A1[1] - A0[1]);\n\n // lines are parallel or conincident\n if (den == 0) {\n return null;\n }\n\n var ua = ((B1[0] - B0[0]) * (A0[1] - B0[1]) -\n (B1[1] - B0[1]) * (A0[0] - B0[0])) / den;\n\n var ub = ((A1[0] - A0[0]) * (A0[1] - B0[1]) -\n (A1[1] - A0[1]) * (A0[0] - B0[0])) / den;\n\n if (ua < 0 || ub < 0 || ua > 1 || ub > 1) {\n return null;\n }\n\n return [\n A0[0] + ua * (A1[0] - A0[0]),\n A0[1] + ua * (A1[1] - A0[1])\n ];\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/polygon-offset/src/intersection.js\n ** module id = 66\n ** module chunks = 0\n **/"],"sourceRoot":"/source/"}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik