(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