(function webpackUniversalModuleDefinition(root, factory) { if(typeof exports === 'object' && typeof module === 'object') module.exports = factory(require("THREE"), require("TweenLite")); else if(typeof define === 'function' && define.amd) define(["THREE", "TweenLite"], factory); else if(typeof exports === 'object') exports["VIZI"] = factory(require("THREE"), require("TweenLite")); else root["VIZI"] = factory(root["THREE"], root["TweenLite"]); })(this, function(__WEBPACK_EXTERNAL_MODULE_12__, __WEBPACK_EXTERNAL_MODULE_55__) { return /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules[moduleId]) /******/ return installedModules[moduleId].exports; /******/ /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules[moduleId] = { /******/ exports: {}, /******/ id: moduleId, /******/ loaded: false /******/ }; /******/ /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ /******/ // Flag the module as loaded /******/ module.loaded = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (__webpack_modules__) /******/ __webpack_require__.m = modules; /******/ /******/ // expose the module cache /******/ __webpack_require__.c = installedModules; /******/ /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ /******/ // Load entry module and return exports /******/ return __webpack_require__(0); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ (function(module, exports, __webpack_require__) { Object.defineProperty(exports, '__esModule', { value: true }); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } var _World = __webpack_require__(1); var _World2 = _interopRequireDefault(_World); var _controlsIndex = __webpack_require__(51); var _controlsIndex2 = _interopRequireDefault(_controlsIndex); var _geoGeoJs = __webpack_require__(8); var _geoGeoJs2 = _interopRequireDefault(_geoGeoJs); var _layerLayer = __webpack_require__(35); var _layerLayer2 = _interopRequireDefault(_layerLayer); var _layerLayerGroup = __webpack_require__(56); var _layerLayerGroup2 = _interopRequireDefault(_layerLayerGroup); var _layerEnvironmentEnvironmentLayer = __webpack_require__(34); var _layerEnvironmentEnvironmentLayer2 = _interopRequireDefault(_layerEnvironmentEnvironmentLayer); var _layerTileImageTileLayer = __webpack_require__(57); var _layerTileImageTileLayer2 = _interopRequireDefault(_layerTileImageTileLayer); var _layerTileGeoJSONTileLayer = __webpack_require__(71); var _layerTileGeoJSONTileLayer2 = _interopRequireDefault(_layerTileGeoJSONTileLayer); var _layerTileTopoJSONTileLayer = __webpack_require__(93); var _layerTileTopoJSONTileLayer2 = _interopRequireDefault(_layerTileTopoJSONTileLayer); var _layerTileMVTTileLayer = __webpack_require__(94); var _layerTileMVTTileLayer2 = _interopRequireDefault(_layerTileMVTTileLayer); var _layerTileGeoJSONTile = __webpack_require__(72); var _layerTileGeoJSONTile2 = _interopRequireDefault(_layerTileGeoJSONTile); var _layerTileMVTTile = __webpack_require__(95); var _layerTileMVTTile2 = _interopRequireDefault(_layerTileMVTTile); var _layerGeoJSONLayer = __webpack_require__(73); var _layerGeoJSONLayer2 = _interopRequireDefault(_layerGeoJSONLayer); var _layerTopoJSONLayer = __webpack_require__(103); var _layerTopoJSONLayer2 = _interopRequireDefault(_layerTopoJSONLayer); var _layerGeoJSONWorkerLayer = __webpack_require__(91); var _layerGeoJSONWorkerLayer2 = _interopRequireDefault(_layerGeoJSONWorkerLayer); var _layerTopoJSONWorkerLayer = __webpack_require__(104); var _layerTopoJSONWorkerLayer2 = _interopRequireDefault(_layerTopoJSONWorkerLayer); var _layerGeometryPolygonLayer = __webpack_require__(88); var _layerGeometryPolygonLayer2 = _interopRequireDefault(_layerGeometryPolygonLayer); var _layerGeometryPolylineLayer = __webpack_require__(89); var _layerGeometryPolylineLayer2 = _interopRequireDefault(_layerGeometryPolylineLayer); var _layerGeometryPointLayer = __webpack_require__(90); var _layerGeometryPointLayer2 = _interopRequireDefault(_layerGeometryPointLayer); var _geoPoint = __webpack_require__(10); var _geoPoint2 = _interopRequireDefault(_geoPoint); var _geoLatLon = __webpack_require__(9); var _geoLatLon2 = _interopRequireDefault(_geoLatLon); var _enginePickingMaterial = __webpack_require__(86); var _enginePickingMaterial2 = _interopRequireDefault(_enginePickingMaterial); var _utilIndex = __webpack_require__(105); var _utilIndex2 = _interopRequireDefault(_utilIndex); var VIZI = { version: '0.3', // Public API World: _World2['default'], world: _World.world, Controls: _controlsIndex2['default'], Geo: _geoGeoJs2['default'], Layer: _layerLayer2['default'], layer: _layerLayer.layer, EnvironmentLayer: _layerEnvironmentEnvironmentLayer2['default'], environmentLayer: _layerEnvironmentEnvironmentLayer.environmentLayer, ImageTileLayer: _layerTileImageTileLayer2['default'], imageTileLayer: _layerTileImageTileLayer.imageTileLayer, GeoJSONTileLayer: _layerTileGeoJSONTileLayer2['default'], geoJSONTileLayer: _layerTileGeoJSONTileLayer.geoJSONTileLayer, GeoJSONTile: _layerTileGeoJSONTile2['default'], geoJSONTile: _layerTileGeoJSONTile.geoJSONTile, MVTTile: _layerTileMVTTile2['default'], mvtTile: _layerTileMVTTile.mvtTile, TopoJSONTileLayer: _layerTileTopoJSONTileLayer2['default'], topoJSONTileLayer: _layerTileTopoJSONTileLayer.topoJSONTileLayer, MVTTileLayer: _layerTileMVTTileLayer2['default'], mvtTileLayer: _layerTileMVTTileLayer.mvtTileLayer, GeoJSONLayer: _layerGeoJSONLayer2['default'], geoJSONLayer: _layerGeoJSONLayer.geoJSONLayer, TopoJSONLayer: _layerTopoJSONLayer2['default'], topoJSONLayer: _layerTopoJSONLayer.topoJSONLayer, GeoJSONWorkerLayer: _layerGeoJSONWorkerLayer2['default'], geoJSONWorkerLayer: _layerGeoJSONWorkerLayer.geoJSONWorkerLayer, TopoJSONWorkerLayer: _layerTopoJSONWorkerLayer2['default'], topoJSONWorkerLayer: _layerTopoJSONWorkerLayer.topoJSONWorkerLayer, PolygonLayer: _layerGeometryPolygonLayer2['default'], polygonLayer: _layerGeometryPolygonLayer.polygonLayer, PolylineLayer: _layerGeometryPolylineLayer2['default'], polylineLayer: _layerGeometryPolylineLayer.polylineLayer, PointLayer: _layerGeometryPointLayer2['default'], pointLayer: _layerGeometryPointLayer.pointLayer, Point: _geoPoint2['default'], point: _geoPoint.point, LatLon: _geoLatLon2['default'], latLon: _geoLatLon.latLon, PickingMaterial: _enginePickingMaterial2['default'], Util: _utilIndex2['default'] }; exports['default'] = VIZI; module.exports = exports['default']; /***/ }), /* 1 */ /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(Promise) {Object.defineProperty(exports, '__esModule', { value: true }); var _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; }; })(); var _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); } } }; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } function _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; } var _eventemitter3 = __webpack_require__(6); var _eventemitter32 = _interopRequireDefault(_eventemitter3); var _lodashAssign = __webpack_require__(7); var _lodashAssign2 = _interopRequireDefault(_lodashAssign); var _geoGeo = __webpack_require__(8); var _geoGeo2 = _interopRequireDefault(_geoGeo); var _geoPoint = __webpack_require__(10); var _geoLatLon = __webpack_require__(9); var _engineEngine = __webpack_require__(11); var _engineEngine2 = _interopRequireDefault(_engineEngine); var _layerEnvironmentEnvironmentLayer = __webpack_require__(34); var _layerEnvironmentEnvironmentLayer2 = _interopRequireDefault(_layerEnvironmentEnvironmentLayer); var _utilWorker = __webpack_require__(48); var _utilWorker2 = _interopRequireDefault(_utilWorker); // TODO: Make sure nothing is left behind in the heap after calling destroy() // Pretty much any event someone using ViziCities would need will be emitted or // proxied by World (eg. render events, etc) var World = (function (_EventEmitter) { _inherits(World, _EventEmitter); function World(domId, options) { var _this = this; _classCallCheck(this, World); _get(Object.getPrototypeOf(World.prototype), 'constructor', this).call(this); var defaults = { skybox: false, postProcessing: false }; this.options = (0, _lodashAssign2['default'])({}, defaults, options); this._layers = []; this._controls = []; this._initContainer(domId); this._initAttribution(); this._initEngine(); this._initEnvironment().then(function () { _this._initEvents(); _this._pause = false; // Kick off the update and render loop _this._update(); }); } _createClass(World, [{ key: 'createWorkers', value: function createWorkers(maxWorkers, workerScript) { return _utilWorker2['default'].createWorkers(maxWorkers, workerScript); } }, { key: '_initContainer', value: function _initContainer(domId) { this._container = document.getElementById(domId); } }, { key: '_initAttribution', value: function _initAttribution() { var message = 'ViziCities | Attribution'; var element = document.createElement('div'); element.classList.add('vizicities-attribution'); var additionalElem = document.createElement('div'); additionalElem.id = 'attribution-container'; element.innerHTML = message; element.appendChild(additionalElem); this._container.appendChild(element); document.getElementById('show-attr').addEventListener('click', function (e) { e.currentTarget.parentNode.classList.toggle('is-visible'); }); } }, { key: '_initEngine', value: function _initEngine() { this._engine = new _engineEngine2['default'](this._container, this); // Engine events // // Consider proxying these through events on World for public access // this._engine.on('preRender', () => {}); // this._engine.on('postRender', () => {}); } }, { key: '_initEnvironment', value: function _initEnvironment() { // Not sure if I want to keep this as a private API // // Makes sense to allow others to customise their environment so perhaps // add some method of disable / overriding the environment settings this._environment = new _layerEnvironmentEnvironmentLayer2['default']({ skybox: this.options.skybox }); return this._environment.addTo(this); } }, { key: '_initEvents', value: function _initEvents() { this.on('controlsMoveEnd', this._onControlsMoveEnd); } }, { key: '_onControlsMoveEnd', value: function _onControlsMoveEnd(point) { var _point = (0, _geoPoint.point)(point.x, point.z); this._resetView(this.pointToLatLon(_point), _point); } // Reset world view }, { key: '_resetView', value: function _resetView(latlon, point) { this.emit('preResetView'); this._moveStart(); this._move(latlon, point); this._moveEnd(); this.emit('postResetView'); } }, { key: '_moveStart', value: function _moveStart() { this.emit('moveStart'); } }, { key: '_move', value: function _move(latlon, point) { this._lastPosition = latlon; this.emit('move', latlon, point); } }, { key: '_moveEnd', value: function _moveEnd() { this.emit('moveEnd'); } }, { key: '_update', value: function _update() { if (this._pause) { return; } var delta = this._engine.clock.getDelta(); // Once _update is called it will run forever, for now window.requestAnimationFrame(this._update.bind(this)); // Update controls // this._controls.forEach(controls => { // controls.update(delta); // }); this.emit('preUpdate', delta); this._engine.update(delta); this.emit('postUpdate', delta); } }, { key: '_addAttribution', value: function _addAttribution(id, message) { var container = document.getElementById('attribution-container'); var span = document.createElement('p'); span.dataset.layer = id; span.innerHTML = message; container.appendChild(span); } }, { key: '_removeAttribution', value: function _removeAttribution(id) { var elem = document.querySelectorAll('#attribution-container [data-layer="' + id + '"]')[0]; if (elem) { elem.remove(); } } // Set world view }, { key: 'setView', value: function setView(latlon) { // Store initial geographic coordinate for the [0,0,0] world position // // The origin point doesn't move in three.js / 3D space so only set it once // here instead of every time _resetView is called // // If it was updated every time then coorindates would shift over time and // would be out of place / context with previously-placed points (0,0 would // refer to a different point each time) this._originLatlon = latlon; this._originPoint = this.project(latlon); this._resetView(latlon); return this; } // Return world geographic position }, { key: 'getPosition', value: function getPosition() { return this._lastPosition; } // Transform geographic coordinate to world point // // This doesn't take into account the origin offset // // For example, this takes a geographic coordinate and returns a point // relative to the origin point of the projection (not the world) }, { key: 'project', value: function project(latlon) { return _geoGeo2['default'].latLonToPoint((0, _geoLatLon.latLon)(latlon)); } // Transform world point to geographic coordinate // // This doesn't take into account the origin offset // // For example, this takes a point relative to the origin point of the // projection (not the world) and returns a geographic coordinate }, { key: 'unproject', value: function unproject(point) { return _geoGeo2['default'].pointToLatLon((0, _geoPoint.point)(point)); } // Takes into account the origin offset // // For example, this takes a geographic coordinate and returns a point // relative to the three.js / 3D origin (0,0) }, { key: 'latLonToPoint', value: function latLonToPoint(latlon) { var projectedPoint = this.project((0, _geoLatLon.latLon)(latlon)); return projectedPoint._subtract(this._originPoint); } // Takes into account the origin offset // // For example, this takes a point relative to the three.js / 3D origin (0,0) // and returns the exact geographic coordinate at that point }, { key: 'pointToLatLon', value: function pointToLatLon(point) { var projectedPoint = (0, _geoPoint.point)(point).add(this._originPoint); return this.unproject(projectedPoint); } // Return pointscale for a given geographic coordinate }, { key: 'pointScale', value: function pointScale(latlon, accurate) { return _geoGeo2['default'].pointScale(latlon, accurate); } // Convert from real meters to world units // // TODO: Would be nice not to have to pass in a pointscale here }, { key: 'metresToWorld', value: function metresToWorld(metres, pointScale, zoom) { return _geoGeo2['default'].metresToWorld(metres, pointScale, zoom); } // Convert from real meters to world units // // TODO: Would be nice not to have to pass in a pointscale here }, { key: 'worldToMetres', value: function worldToMetres(worldUnits, pointScale, zoom) { return _geoGeo2['default'].worldToMetres(worldUnits, pointScale, zoom); } // Unsure if it's a good idea to expose this here for components like // GridLayer to use (eg. to keep track of a frustum) }, { key: 'getCamera', value: function getCamera() { return this._engine._camera; } }, { key: 'addLayer', value: function addLayer(layer) { var _this2 = this; // Is is right to assume that there will always be some other layer // managing layers with output set to false? this._layers.push(layer); if (layer.isOutput() && layer.isOutputToScene()) { // Could move this into Layer but it'll do here for now this._engine._scene.add(layer._object3D); this._engine._domScene3D.add(layer._domObject3D); this._engine._domScene2D.add(layer._domObject2D); } return new Promise(function (resolve, reject) { layer._addToWorld(_this2).then(function () { if (layer._options.attribution) { _this2._addAttribution(layer._options.id, layer._options.attribution); } // TODO: Consider moving this so it doesn't fire for layers that are // actually managed by a parent layer (eg. tiles) _this2.emit('layerAdded', layer); resolve(_this2); })['catch'](reject); }); } // Remove layer from world and scene but don't destroy it entirely }, { key: 'removeLayer', value: function removeLayer(layer) { var layerIndex = this._layers.indexOf(layer); if (layerIndex > -1) { // Remove from this._layers this._layers.splice(layerIndex, 1); }; if (layer._options.attribution) { this._removeAttribution(layer._options.id); } if (layer.isOutput() && layer.isOutputToScene()) { this._engine._scene.remove(layer._object3D); this._engine._domScene3D.remove(layer._domObject3D); this._engine._domScene2D.remove(layer._domObject2D); } this.emit('layerRemoved'); return Promise.resolve(this); } }, { key: 'addControls', value: function addControls(controls) { controls._addToWorld(this); this._controls.push(controls); this.emit('controlsAdded', controls); return Promise.resolve(this); } // Remove controls from world but don't destroy them entirely }, { key: 'removeControls', value: function removeControls(controls) { var controlsIndex = this._controls.indexOf(controlsIndex); if (controlsIndex > -1) { this._controls.splice(controlsIndex, 1); }; this.emit('controlsRemoved', controls); return Promise.resolve(this); } }, { key: 'stop', value: function stop() { this._pause = true; } }, { key: 'start', value: function start() { this._pause = false; this._update(); } // Destroys the world(!) and removes it from the scene and memory // // TODO: World out why so much three.js stuff is left in the heap after this }, { key: 'destroy', value: function destroy() { this.stop(); // Remove listeners this.off('controlsMoveEnd', this._onControlsMoveEnd); var i; // Remove all controls var controls; for (i = this._controls.length - 1; i >= 0; i--) { controls = this._controls[0]; this.removeControls(controls); controls.destroy(); }; // Remove all layers var layer; for (i = this._layers.length - 1; i >= 0; i--) { layer = this._layers[0]; this.removeLayer(layer); layer.destroy(); }; // Environment layer is removed with the other layers this._environment = null; this._engine.destroy(); this._engine = null; // Clean the container / remove the canvas while (this._container.firstChild) { this._container.removeChild(this._container.firstChild); } this._container = null; } }]); return World; })(_eventemitter32['default']); exports['default'] = World; var noNew = function noNew(domId, options) { return new World(domId, options); }; // Initialise without requiring new keyword exports.world = noNew; /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2))) /***/ }), /* 2 */ /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(setImmediate) {(function (root) { // Store setTimeout reference so promise-polyfill will be unaffected by // other code modifying setTimeout (like sinon.useFakeTimers()) var setTimeoutFunc = setTimeout; function noop() {} // Polyfill for Function.prototype.bind function bind(fn, thisArg) { return function () { fn.apply(thisArg, arguments); }; } function Promise(fn) { if (!(this instanceof Promise)) throw new TypeError('Promises must be constructed via new'); if (typeof fn !== 'function') throw new TypeError('not a function'); this._state = 0; this._handled = false; this._value = undefined; this._deferreds = []; doResolve(fn, this); } function handle(self, deferred) { while (self._state === 3) { self = self._value; } if (self._state === 0) { self._deferreds.push(deferred); return; } self._handled = true; Promise._immediateFn(function () { var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected; if (cb === null) { (self._state === 1 ? resolve : reject)(deferred.promise, self._value); return; } var ret; try { ret = cb(self._value); } catch (e) { reject(deferred.promise, e); return; } resolve(deferred.promise, ret); }); } function resolve(self, newValue) { try { // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.'); if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { var then = newValue.then; if (newValue instanceof Promise) { self._state = 3; self._value = newValue; finale(self); return; } else if (typeof then === 'function') { doResolve(bind(then, newValue), self); return; } } self._state = 1; self._value = newValue; finale(self); } catch (e) { reject(self, e); } } function reject(self, newValue) { self._state = 2; self._value = newValue; finale(self); } function finale(self) { if (self._state === 2 && self._deferreds.length === 0) { Promise._immediateFn(function() { if (!self._handled) { Promise._unhandledRejectionFn(self._value); } }); } for (var i = 0, len = self._deferreds.length; i < len; i++) { handle(self, self._deferreds[i]); } self._deferreds = null; } function Handler(onFulfilled, onRejected, promise) { this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null; this.onRejected = typeof onRejected === 'function' ? onRejected : null; this.promise = promise; } /** * Take a potentially misbehaving resolver function and make sure * onFulfilled and onRejected are only called once. * * Makes no guarantees about asynchrony. */ function doResolve(fn, self) { var done = false; try { fn(function (value) { if (done) return; done = true; resolve(self, value); }, function (reason) { if (done) return; done = true; reject(self, reason); }); } catch (ex) { if (done) return; done = true; reject(self, ex); } } Promise.prototype['catch'] = function (onRejected) { return this.then(null, onRejected); }; Promise.prototype.then = function (onFulfilled, onRejected) { var prom = new (this.constructor)(noop); handle(this, new Handler(onFulfilled, onRejected, prom)); return prom; }; Promise.all = function (arr) { return new Promise(function (resolve, reject) { if (!arr || typeof arr.length === 'undefined') throw new TypeError('Promise.all accepts an array'); var args = Array.prototype.slice.call(arr); if (args.length === 0) return resolve([]); var remaining = args.length; function res(i, val) { try { if (val && (typeof val === 'object' || typeof val === 'function')) { var then = val.then; if (typeof then === 'function') { then.call(val, function (val) { res(i, val); }, reject); return; } } args[i] = val; if (--remaining === 0) { resolve(args); } } catch (ex) { reject(ex); } } for (var i = 0; i < args.length; i++) { res(i, args[i]); } }); }; Promise.resolve = function (value) { if (value && typeof value === 'object' && value.constructor === Promise) { return value; } return new Promise(function (resolve) { resolve(value); }); }; Promise.reject = function (value) { return new Promise(function (resolve, reject) { reject(value); }); }; Promise.race = function (values) { return new Promise(function (resolve, reject) { for (var i = 0, len = values.length; i < len; i++) { values[i].then(resolve, reject); } }); }; // Use polyfill for setImmediate for performance gains Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) || function (fn) { setTimeoutFunc(fn, 0); }; Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) { if (typeof console !== 'undefined' && console) { console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console } }; /** * Set the immediate function to execute callbacks * @param fn {function} Function to execute * @deprecated */ Promise._setImmediateFn = function _setImmediateFn(fn) { Promise._immediateFn = fn; }; /** * Change the function to execute on unhandled rejection * @param {function} fn Function to execute on unhandled rejection * @deprecated */ Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) { Promise._unhandledRejectionFn = fn; }; if (typeof module !== 'undefined' && module.exports) { module.exports = Promise; } else if (!root.Promise) { root.Promise = Promise; } })(this); /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3).setImmediate)) /***/ }), /* 3 */ /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) || (typeof self !== "undefined" && self) || window; var apply = Function.prototype.apply; // DOM APIs, for completeness exports.setTimeout = function() { return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout); }; exports.setInterval = function() { return new Timeout(apply.call(setInterval, scope, arguments), clearInterval); }; exports.clearTimeout = exports.clearInterval = function(timeout) { if (timeout) { timeout.close(); } }; function Timeout(id, clearFn) { this._id = id; this._clearFn = clearFn; } Timeout.prototype.unref = Timeout.prototype.ref = function() {}; Timeout.prototype.close = function() { this._clearFn.call(scope, this._id); }; // Does not start the time, just sets up the members needed. exports.enroll = function(item, msecs) { clearTimeout(item._idleTimeoutId); item._idleTimeout = msecs; }; exports.unenroll = function(item) { clearTimeout(item._idleTimeoutId); item._idleTimeout = -1; }; exports._unrefActive = exports.active = function(item) { clearTimeout(item._idleTimeoutId); var msecs = item._idleTimeout; if (msecs >= 0) { item._idleTimeoutId = setTimeout(function onTimeout() { if (item._onTimeout) item._onTimeout(); }, msecs); } }; // setimmediate attaches itself to the global object __webpack_require__(4); // On some exotic environments, it's not clear which object `setimmediate` was // able to install onto. Search each possibility in the same order as the // `setimmediate` library. exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) || (typeof global !== "undefined" && global.setImmediate) || (this && this.setImmediate); exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) || (typeof global !== "undefined" && global.clearImmediate) || (this && this.clearImmediate); /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) /***/ }), /* 4 */ /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) { "use strict"; if (global.setImmediate) { return; } var nextHandle = 1; // Spec says greater than zero var tasksByHandle = {}; var currentlyRunningATask = false; var doc = global.document; var registerImmediate; function setImmediate(callback) { // Callback can either be a function or a string if (typeof callback !== "function") { callback = new Function("" + callback); } // Copy function arguments var args = new Array(arguments.length - 1); for (var i = 0; i < args.length; i++) { args[i] = arguments[i + 1]; } // Store and register the task var task = { callback: callback, args: args }; tasksByHandle[nextHandle] = task; registerImmediate(nextHandle); return nextHandle++; } function clearImmediate(handle) { delete tasksByHandle[handle]; } function run(task) { var callback = task.callback; var args = task.args; switch (args.length) { case 0: callback(); break; case 1: callback(args[0]); break; case 2: callback(args[0], args[1]); break; case 3: callback(args[0], args[1], args[2]); break; default: callback.apply(undefined, args); break; } } function runIfPresent(handle) { // From the spec: "Wait until any invocations of this algorithm started before this one have completed." // So if we're currently running a task, we'll need to delay this invocation. if (currentlyRunningATask) { // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a // "too much recursion" error. setTimeout(runIfPresent, 0, handle); } else { var task = tasksByHandle[handle]; if (task) { currentlyRunningATask = true; try { run(task); } finally { clearImmediate(handle); currentlyRunningATask = false; } } } } function installNextTickImplementation() { registerImmediate = function(handle) { process.nextTick(function () { runIfPresent(handle); }); }; } function canUsePostMessage() { // The test against `importScripts` prevents this implementation from being installed inside a web worker, // where `global.postMessage` means something completely different and can't be used for this purpose. if (global.postMessage && !global.importScripts) { var postMessageIsAsynchronous = true; var oldOnMessage = global.onmessage; global.onmessage = function() { postMessageIsAsynchronous = false; }; global.postMessage("", "*"); global.onmessage = oldOnMessage; return postMessageIsAsynchronous; } } function installPostMessageImplementation() { // Installs an event handler on `global` for the `message` event: see // * https://developer.mozilla.org/en/DOM/window.postMessage // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages var messagePrefix = "setImmediate$" + Math.random() + "$"; var onGlobalMessage = function(event) { if (event.source === global && typeof event.data === "string" && event.data.indexOf(messagePrefix) === 0) { runIfPresent(+event.data.slice(messagePrefix.length)); } }; if (global.addEventListener) { global.addEventListener("message", onGlobalMessage, false); } else { global.attachEvent("onmessage", onGlobalMessage); } registerImmediate = function(handle) { global.postMessage(messagePrefix + handle, "*"); }; } function installMessageChannelImplementation() { var channel = new MessageChannel(); channel.port1.onmessage = function(event) { var handle = event.data; runIfPresent(handle); }; registerImmediate = function(handle) { channel.port2.postMessage(handle); }; } function installReadyStateChangeImplementation() { var html = doc.documentElement; registerImmediate = function(handle) { // Create a